Bu yenileme işlemini yaparken NextJS frameworkünü ve trend olan Radix UI’ın Tailwind formatına dönüştürülmüş hali olan shadcn/ui componentlerini kullandık. Ancak bu component kütüphanesinin içerisinde transfer componenti bulunmuyordu.

Transfer componenti nedir?

Transfer componenti pasif/aktif olan iki tarafın tek ekranda görüntülenerek sergilenen itemların durumlarının hızlıca değiştirilmesine olanak sağlayan bir component türüdür.

Biz bu componenti kullanıcılara atabilen yetkileri ve halihazırda atanmış yetkileri görüntüleyip hızlıca değişiklik sağlayabileceği bir durumun kullanıcı deneyimini geliştirmek için yaptık.

Yukarıda görebileceğiniz üzere oluşturulmuş bir yetkiye hangi kullanıcının sahip olabileceğini ve hangi kullanıcıların halihazırda sahip olduğunu görüntüleyebiliyor ve bu kullanıcıların sahiplik durumları arasında hızlıca değişiklik gerçekleştirebiliyoruz.

React Transfer componentini nasıl geliştirebilirim?

Bu componentin geliştirilmesini ben Tailwind ve Typescript kullanarak anlatacağım. Ayrıca kullandığım kütüphaneden gelen Checkbox, Button gibi inputları kendi kütüphanenizdekiler ile değiştirmeniz gerekebilir.

Kullanacağımız stateleri belirleyelim

checked

Seçilmiş olduğumuz elemanları tutacağımız state. Tip (T[])

left

Sol kısmımızda (seçilmemiş) olan elemanları tuttuğumuz state. Tip (T[])

right

Sağ kısımda (seçilmiş) olan elemanları tuttuğumuz state. Tip (T[])

Kullanacağımız fonksiyonları oluşturalım

not

a ve b olarak T[] tipinde iki argüman alır, a’nın b’yi içermeyen elemanlarını belirler.

function not(a: T[], b: T[]) {
  return a.filter((value) => b.indexOf(value) === -1)
}

intersection

a ve b olarak T[] tipinde iki argüman alır, a’nın b’yi içeren elemanlarını belirler.

function intersection(a: T[], b: T[]) {
  return a.filter((value) => b.indexOf(value) !== -1)
}

union

a ve b olarak T[] tipinde iki argüman alır, iki taraftaki elemanları sadece unique olacak şekilde birleştirir.

function union(a: T[], b: T[]) {
  return [...a, ...not(b, a)]
}

numberOfChecked

Verdiğimiz taraftaki itemların kaçının seçili olduğunu intersection kullanarak bulur.

const numberOfChecked = (items: T[]) => intersection(checked, items).length

handleToggle

Bu fonksiyon işaretlediğimiz elemanın checked stateine eklenmesini ya da çıkarılması işlemini sağlar.

const handleToggle = (value: T) => () => {
  const currentIndex = checked.indexOf(value)
  const newChecked = [...checked]

  if (currentIndex === -1) {
    newChecked.push(value)
  } else {
    newChecked.splice(currentIndex, 1)
  }

  setChecked(newChecked)
}

handleToggleAll

Belirttiğimiz taraftaki tüm itemların seçilmesini ya da seçimlerinin kaldırılmasını sağlar.

const handleToggleAll = (items: T[]) => () => {
  if (numberOfChecked(items) === items.length) {
    setChecked(not(checked, items))
  } else {
    setChecked(union(checked, items))
  }
}

leftChecked / rightChecked

intersection fonksiyonumuzu kullanarak hangi itemların seçili olduğunu bulur.

const leftChecked = intersection(checked, left)
const rightChecked = intersection(checked, right)

handleCheckedLeft / handleCheckedRight

Orta kısımdaki butonlarımızın sağa ya da sola gönderme işlemlerini yaptığımız fonksiyonlar bütünüdür. Bir taraftaki itemlardan seçili olanları öbür kısım ile birleştirir ve diğer taraftan kaldırma işlemlerini yaptıktan sonra checked stateinden kaldırır.

const handleCheckedRight = () => {
  setRight(right.concat(leftChecked))
  setLeft(not(left, leftChecked))
  setChecked(not(checked, leftChecked))
}

const handleCheckedLeft = () => {
  setLeft(left.concat(rightChecked))
  setRight(not(right, rightChecked))
  setChecked(not(checked, rightChecked))
}

View kısımlarımızı oluşturalım

Bu component iki adet aynı kutudan ve bir flexbox içerisinde bulunan alt alta iki düğmeden oluşmaktadır. İlk aşamada sol ve sağ kısımlarımız aynı olduğundan tek bir component yazalım.

Checkboxlu kutuların geliştirilmesi

// Itemlar ve başlığa ihtiyacımız mevcut
const customList = (items: T[], title: string) => {
  return (
    <Card className="flex-1">
      <CardHeader>
        {/* Başlık propumuzu bu alanda kullanıyoruz */}
        <CardTitle>{title}</CardTitle>
      </CardHeader>
      <CardContent>
        <div className="flex items-center space-x-2">
          {/* handleToggleAll fonksiyonumuzu bu alanda kullanarak tümünün seçilebilmesini sağlıyoruz */}
          <Checkbox
            id={`select_all_${title}`}
            onClick={handleToggleAll(items)}
            checked={
              numberOfChecked(items) === items.length && items.length !== 0
            }
            disabled={items.length === 0}
          />
          <Label
            htmlFor={`select_all_${title}`}
            className="text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70"
          >
            Tümünü seç {/* kaç adet item seçtiğimizi belirtiyoruz */}
            {items.length > 0 &&
              `(${numberOfChecked(items)}/${items.length} seçili)`}
          </Label>
        </div>

        <Separator className="my-6" />
        <ScrollArea className="h-72">
          <div className="flex flex-col gap-4">
            {/* hiç item yoksa veya kalmadıysa boş state'in gösterimi */}
            {items.length === 0 && (
              <div className="flex flex-col items-center justify-center gap-3">
                <FolderOpen className="h-8 w-8 text-foreground/70" />
                <span className="text-sm font-medium leading-none text-foreground/70">
                  Veri yok
                </span>
              </div>
            )}

            {/* itemların checkboxları ve labelları koyularak seçilebilir şekilde listelenmesi */}
            {items.map((value) => {
              return (
                <div className="flex items-center space-x-2" key={value.id}>
                  {/* işaretlendiğinde valuenun değerinin toggle edildiği durum */}
                  <Checkbox
                    id={value.id}
                    onClick={handleToggle(value)}
                    checked={checked.indexOf(value) !== -1}
                  />
                  <Label
                    htmlFor={value.id}
                    className="text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70"
                  >
                    {value.name}
                  </Label>
                </div>
              );
            })}
          </div>
        </ScrollArea>
      </CardContent>
    </Card>
  );
};

Tüm componentlerin bir araya getirilmesi

return (
  <div>
    <div className="flex gap-5">
      {/* Sol kısmın renderlanması */}
      {customList(left, props.leftTitle)}

      <div className="buttons flex flex-col items-center justify-center gap-3">
        {/* Sağda seçililerin sol tarafa taşınmasını sağlayan buton */}
        <Button
          variant="outline"
          onClick={() => handleCheckedLeft()}
          disabled={rightChecked.length === 0}
        >
          <ChevronLeft className="h-4 w-4" />
        </Button>
        {/* Solda seçililerin sağ tarafa taşınmasını sağlayan buton */}
        <Button
          variant="outline"
          onClick={() => handleCheckedRight()}
          disabled={leftChecked.length === 0}
        >
          <ChevronRight className="h-4 w-4" />
        </Button>
      </div>

      {/* Sağ kısmın renderlanması */}
      {customList(right, props.rightTitle)}
    </div>

    {/* Eğer tanımlandıysa kaydet fonksiyonu ile birlikte kaydet düğmesinin gösterilmesi*/}
    {props.onSave && (
      <div className="mt-5 flex justify-end">
        <Button onClick={() => props.onSave && props.onSave(right)}>
          <Save className="mr-2 h-4 w-4" /> Kaydet
        </Button>
      </div>
    )}
  </div>
);

Transfer componentinin tamamlanmış hali

interface ITransferListItem {
  id: string
  name: string
}

interface ITransferListProps<T extends ITransferListItem> {
  items: T[]
  selected?: T[]
  leftTitle: string
  rightTitle: string
  loading: boolean
  onSave?: (items: T[]) => void
  renderName?: keyof T
}

const TransferList = <T extends ITransferListItem>(
  props: ITransferListProps<T>
) => {
  const [checked, setChecked] = useState<T[]>([])
  const [left, setLeft] = useState<T[]>([])
  const [right, setRight] = useState<T[]>([])
  const [leftSearch, setLeftSearch] = useState<string>("")
  const [rightSearch, setRightSearch] = useState<string>("")

  const handleSelectedProp = () => {
    if (!props.selected) return

    // Remove selected items from left side
    setLeft((prev) =>
      prev.filter(
        (object1) =>
          !props.selected?.some((object2) => object1.id === object2.id)
      )
    )
    setRight(props.selected)
  }

  useEffect(() => {
    setLeft(props.items)
    handleSelectedProp()
  }, [props.items, props.selected])

  const leftChecked = intersection(checked, left)
  const rightChecked = intersection(checked, right)

  function not(a: T[], b: T[]) {
    return a.filter((value) => b.indexOf(value) === -1)
  }

  function intersection(a: T[], b: T[]) {
    return a.filter((value) => b.indexOf(value) !== -1)
  }

  function union(a: T[], b: T[]) {
    return [...a, ...not(b, a)]
  }

  const numberOfChecked = (items: T[]) => intersection(checked, items).length

  const handleToggle = (value: T) => () => {
    const currentIndex = checked.indexOf(value)
    const newChecked = [...checked]

    if (currentIndex === -1) {
      newChecked.push(value)
    } else {
      newChecked.splice(currentIndex, 1)
    }

    setChecked(newChecked)
  }

  const handleToggleAll = (items: T[]) => () => {
    if (numberOfChecked(items) === items.length) {
      setChecked(not(checked, items))
    } else {
      setChecked(union(checked, items))
    }
  }

  const handleCheckedRight = () => {
    setRight(right.concat(leftChecked))
    setLeft(not(left, leftChecked))
    setChecked(not(checked, leftChecked))
  }

  const handleCheckedLeft = () => {
    setLeft(left.concat(rightChecked))
    setRight(not(right, rightChecked))
    setChecked(not(checked, rightChecked))
  }

  const customList = (
    items: T[],
    title: string,
    search: string,
    setSearch: (e: string) => void
  ) => {
    return (
      <Card className="flex-1">
        <CardHeader>
          <CardTitle>{title}</CardTitle>
        </CardHeader>
        <CardContent>
          <div className="flex items-center space-x-2">
            <Checkbox
              id={`select_all_${title}`}
              onClick={handleToggleAll(items)}
              checked={
                numberOfChecked(items) === items.length && items.length !== 0
              }
              disabled={items.length === 0}
            />
            <Label
              htmlFor={`select_all_${title}`}
              className="text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70"
            >
              Tümünü seç{" "}
              {items.length > 0 &&
                `(${numberOfChecked(items)}/${items.length} seçili)`}
            </Label>
          </div>

          <Separator className="my-6" />
          <div className="search relative">
            <Input
              placeholder="Arama..."
              className="mb-6 h-8"
              value={search}
              onChange={(e) => setSearch(e.target.value)}
            />
            <Search className="absolute right-2 top-2 h-4 w-4 text-foreground/70" />
          </div>

          <ScrollArea className="h-72">
            <div className="flex flex-col gap-4">
              {props.loading && (
                <>
                  {[...Array(10)].map((_, index) => (
                    <div className="flex gap-2" key={index}>
                      <Skeleton className="h-4 w-4" />
                      <Skeleton className="h-4 w-full" />
                    </div>
                  ))}
                </>
              )}
              {!props.loading &&
                items.filter((item) => item.name.toLowerCase().includes(search))
                  .length === 0 && (
                  <div className="flex flex-col items-center justify-center gap-3">
                    <FolderOpen className="h-8 w-8 text-foreground/70" />
                    <span className="text-sm font-medium leading-none text-foreground/70">
                      Veri yok
                    </span>
                  </div>
                )}
              {items
                .filter((item) => item.name.toLowerCase().includes(search))
                .map((value) => {
                  return (
                    <div className="flex items-center space-x-2" key={value.id}>
                      <Checkbox
                        id={value.id}
                        onClick={handleToggle(value)}
                        checked={checked.indexOf(value) !== -1}
                      />
                      <Label
                        htmlFor={value.id}
                        className="text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70"
                      >
                        {props.renderName
                          ? value[props.renderName]
                          : value.name}
                      </Label>
                    </div>
                  )
                })}
            </div>
          </ScrollArea>
        </CardContent>
      </Card>
    )
  }

  return (
    <div>
      <div className="flex gap-5">
        {customList(left, props.leftTitle, leftSearch, setLeftSearch)}
        <div className="buttons flex flex-col items-center justify-center gap-3">
          <Button
            variant="outline"
            onClick={() => handleCheckedLeft()}
            disabled={rightChecked.length === 0}
          >
            <ChevronLeft className="h-4 w-4" />
          </Button>
          <Button
            variant="outline"
            onClick={() => handleCheckedRight()}
            disabled={leftChecked.length === 0}
          >
            <ChevronRight className="h-4 w-4" />
          </Button>
        </div>
        {customList(right, props.rightTitle, rightSearch, setRightSearch)}
      </div>

      {props.onSave && (
        <div className="mt-5 flex justify-end">
          <Button onClick={() => props.onSave && props.onSave(right)}>
            <Save className="mr-2 h-4 w-4" /> Kaydet
          </Button>
        </div>
      )}
    </div>
  )
}

export default TransferList

Örnek kullanım senaryosu

<TransferList
  items={users}
  selected={selected}
  loading={loading}
  leftTitle="Bu role sahip olmayan kullanıcılar"
  rightTitle="Bu role sahip kullanıcılar"
  onSave={onSave}
/>

Son düşünceler

Bu componenti Material UI kütüphanesinden algoritma ve görünüşünü esinlenerek geliştirdim. Kodların en doğru patternda yazıldığını da düşünmüyorum. Şurası şu şekilde değiştirilirse daha doğru olur diyenler olursa gerekli güncellemeleri yapmak isterim.

Okuduğunuz için teşekkür ederim, umarım faydalı olmuştur.

Karşılaştığım ve çözüm getireceğimiz sorun ise bir nesnenin içindeki ilişkisel verilerin kısıtlı sayıda getirilmesi problemidir. Daha detaylı olarak şu şekilde bahsedebiliriz.

Yukarıdaki yapıda bir tablomuz olduğunu ve ikisi arasında one to many ilişkisi olduğunu varsayalım. GORM üzerinde şu şekilde bir dönüş beklediğimizde preload işlemi yapıyoruz.

[
  {
    "id": 1,
    "content": "1. içerik",
    "comments": [
      {
        "id": 1,
        "content": "1. yorum"
      },
      {
        "id": 2,
        "content": "2. yorum"
      },
      {
        "id": 3,
        "content": "3. yorum"
      },
      {
        "id": 4,
        "content": "4. yorum"
      }
      // belki 1000 yorumdan fazla var?
    ]
  },
  {
    "id": 2,
    "content": "2. içerik",
    "comments": [
      {
        "id": 5,
        "content": "1. yorum"
      },
      {
        "id": 6,
        "content": "2. yorum"
      }
    ]
  }
]

Preload kullandığımızda gördüğünüz gibi iki içeriğin de yorumları başarıyla yüklendi. Ancak bu içeriklerin 500+ yorumu olduğunda preload yaptığımızda ne yapacağız?

İnternette önerilen kılavuz şu şekilde:

posts := []*models.Post{}
database.Connection().Model(&posts).Preload(“Comments”, func(tx *gorm.DB) *gorm.DB {
    return tx.Limit(2)
})

Görünüş olarak bir sıkıntı gözükmese de bu bizim beklediğimiz çalışma biçimine malesef sahip değil. Yukarıdaki kod bloğu tx.Limit(2) dediğinizde her Post nesnesi için 2 adet değil o anda çekilen tüm Post nesneleri için toplam 2 adet Comment döndürecektir. Çıktı olarak alacağınız sonuç bu şekildedir.

[
  {
    "id": 1,
    "content": "1. içerik",
    "comments": [
      {
        "id": 1,
        "content": "1. yorum"
      },
      {
        "id": 2,
        "content": "2. yorum"
      }
    ]
  },
  {
    "id": 2,
    "content": "2. içerik",
    "comments": [
        // aslında devamı var ancak çekmiyor :)
        // çünkü toplamda 2 adet nesne çekti ve query’i sonlandırdı
    ]
  }
]

Çözümü için ise yukarıdaki kod bloğuna daha komplike bir SQL sorgusu yazmamız gerekecek. Burada imdadımıza lateral join ve distinct selection yetişiyor. 

posts := []*models.Post{}
database.Connection().Model(&posts).Preload("Comments", func(tx *gorm.DB) *gorm.DB {
    return tx.Joins(`
        JOIN LATERAL (
            SELECT DISTINCT c.post_id FROM comments c WHERE c.post_id = comments.post_id LIMIT 2
        ) AS cm ON cm.post_id = comments.post_id
    `)
})

Yukarıdaki şekilde join işlemi yaptığımızda beklediğimiz çıktıyı alacağız.

Örnek çıktı:

[
  {
    "id": 1,
    "content": "1. içerik",
    "comments": [
      {
        "id": 1,
        "content": "1. yorum"
      },
      {
        "id": 2,
        "content": "2. yorum"
      }
    ]
  },
  {
    "id": 2,
    "content": "2. içerik",
    "comments": [
      {
        "id": 5,
        "content": "1. yorum"
      },
      {
        "id": 6,
        "content": "2. yorum"
      }
    ]
  }
]

Okuduğunuz için teşekkür ederim, umarım faydalı olmuştur :) Sağlıcakla kalın.

Bu makalemizde Golang üzerindeki Gofiber frameworkü üzerinde nasıl integration test geliştirebiliriz bu konu üzerine konuşacağız. Integration test nedir buna değinerek başlayabiliriz.

Integration test nedir?

Integration test unitlerin birleştiğinde istenilen davranışı sergilemesini kontrol ettiğimiz testler bütünüdür. Örnek olarak bahsedersek uygulamamızda A, B ve C işlemleri için unit testler geliştirdik ve üç işlem de testlere uygun çıktılar sağladı. Ardından bu üç işlemi kullanarak farklı işlemler gerçekleştiren yeni bir fonksiyon oluşturduk. Bu fonksiyonun test edilmesine integration test diyebiliriz. 
Aynı zamanda HTTP testleri de integration testlerine girmektedir. Bugün vereceğimiz örneklerimizde de Fiber Handler yani controllerlarımız üzerinde test gerçekleştireceğiz.

Integration test önemi nedir?

Integration testleri uygulamamızda yüksek önem taşımaktadır. Testlerin yazıldığı fonksiyonlar üzerinde değişiklikler gerçekleştiğinde uygulama halen belirtilen çıktıları bize sağlıyor mu, düzgün şekilde işleyişi mevcut mu bunları göz ile görmektense otomatik şekilde tespitini sağlamaktadır. Anlaşılması için bir örnek sunalım.

Sisteminizde login olmanızı sağlayan ve JWT token üreten bir kontrolcü mevcut olduğunu varsayalım. Bu kontrolcünün doğru şekilde çalıştığından emin olmamız için önce bir dummy user oluşturmamız gerekir. İlk aşamadaki testimiz bizim kullanıcımızın oluşup oluşmadığını kontrol etmektedir. Eğer ilk testte belirtilen çıktı gerçekleştiyse login işlemini gerçekleştirebiliriz. İkinci test koşulu olarak da oluşturulmuş kullanıcının gerçekten giriş yaptığında JWT token elde edebildiğini kontrol etmemiz gerekir. Bu iki koşul sağlandığında sisteminizdeki kullanıcılar gerçek ortamda da sorunsuz şekilde giriş yapabildiğini varsayabiliriz. Önemi ise bu login sistemi üzerinde iyileştirmeler ve yeni eklemeler yaptığınızda hata çıkma olasılığı her an mevcuttur ancak yazdığımız bu testler sayesinde tek tuş ile kullanıcılar halen başarılı şekilde akışa uygun işlem gerçekleştirebiliyor mu test edebiliriz.

Test koşullarını nasıl hazırlarım?

Buradaki önemli kısım platform bağımlı düşünmek değil, bu uygulamanın otomatize testlerinde ne gibi koşullarla karşılaşılmasının beklendiğidir. Örneğin bir modelinizde CRUD işlemleri gerçekleştiren handlerlarınız olduğunu düşünün. Create işleminde test edeceğimiz şey validasyonların gerçekten çalıştığının kontrolü (boş alanlar, unique alan ihlali…), doğru girdiler verildiğinde gerçekten istenilen çıktı elde edilir mi bunların kontrolü yapılır. Delete işleminde hiç varolmayan bir girdi verildiğinde HTTP response kodu ne döner, hata mesajı gerçekten handle edilmiş midir gibi koşulları kontrol edersiniz. Bu noktada oluşturacağınız testler tamamen hayal gücünüze kalmış ancak yukarıdakiler temel olarak bulundurabileceğiniz örneklerdir.

Gofiber ile Integration Test nasıl geliştirilir?

Gofiber üzerinde integration testleri geliştirmek için klasik Golang test şablonundan dışarı çıkmayacağız. Ben dış bir kütüphane eklemedim (testify gibi) ancak bunun tercihi de size kalmış. Önemli olan temel mantığı kavramak.

Ben örnek testimizi daha önce paylaştığım golang-rest-api-boilerplate üzerinden anlatacağım. O örnekte tanımladığımız Post modeli üzerindeki Index ve Create handlerlarına test geliştirdim. Burada bir Create handlerine nasıl test yazmışım bunu inceleyelim.

İlk önce create_test.go dosyamı create.go dosyasının bulunduğu dizinde oluşturuyorum. Ardından dosyanın içeriğini aşağıdaki şekilde tanımlıyorum. Tanımlamanın ardından gerekli kod blokları üzerine konuşacağım.

package post
 
import (
    "bytes"
    "encoding/json"
    "io"
    "net/http/httptest"
    "testing"
 
    "github.com/gofiber/fiber/v2"
)
 
func TestCreate(t *testing.T) {
    type wanted struct {
        statusCode   int
        expectedKeys []string
    }
 
    // Create fiber app for testing purposes
    app := fiber.New()
    app.Post("/", Create)
 
    // Tests struct
    tests := []struct {
        name        string
        description string
        endpoint    string
        payload     any
        want        wanted
    }{
        {
            name:        "Create a fake post",
            description: "This test should return 200 status code and created post",
            endpoint:    "/",
            payload: map[string]any{
                "title":   "Example post",
                "content": "Lorem ipsum",
            },
            want: wanted{
                statusCode: 200,
                expectedKeys: []string{
                    "id",
                    "title",
                    "content",
                },
            },
        },
        {
            name:        "Create a post with blank content",
            description: "This test should return 400 status code and error message",
            endpoint:    "/",
            payload: map[string]any{
                "title":   "Example post2",
                "content": "",
            },
            want: wanted{
                statusCode: 400,
                expectedKeys: []string{
                    "message",
                },
            },
        },
    }
 
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            body, err := json.Marshal(tt.payload)
            if err != nil {
                t.Errorf("Cannot parse body: %v", err)
                t.Fail()
            }
 
            req := httptest.NewRequest("POST", tt.endpoint, bytes.NewReader(body))
            req.Header.Add("Content-Type", "application/json")
 
            // Create request
            res, err := app.Test(req)
            if err != nil {
                t.Errorf("Cannot test Fiber handler: %v", err)
                t.Fail()
            }
 
            // Assertions
            if res.StatusCode != tt.want.statusCode {
                t.Errorf("Expected status code %d, got %d", tt.want.statusCode, res.StatusCode)
            }
 
            answer, err := io.ReadAll(res.Body)
            if err != nil {
                t.Errorf("Cannot parse body: %v", err)
            }
 
            var message map[string]any
            err = json.Unmarshal([]byte(answer), &message)
            if err != nil {
                t.Errorf("Cannot unmarshal response: %v", err)
            }
 
            for _, s := range tt.want.expectedKeys {
                if _, ok := message[s]; !ok {
                    t.Errorf("Expected response body to contain key %s but it can not be found", s)
                }
            }
        })
    }
}

İlk aşamada TestCreate isimli fonksiyonumuzu oluşturuyor ve inbuilt test kütüphanesini parametre olarak fonksiyona ekliyoruz.

Ardından testin çıktısından tam olarak ne beklediğime dair verileri ekleyeceğim wanted isimli bir struct tanımlıyorum. Ben dönen status codeları ve bodyden gelen JSON keylerini kontrol etmek istiyorum. Bu alanları structumda oluşturuyorum.

Bir gofiber uygulamasını test etmek için fiber.New() diyerek fiber uygulamamı oluşturuyorum. Ardından test edeceğim handlerin rotasını ekliyorum. Siz isterseniz birden çok rota ekleyerek zincirleme testler de geliştirebilirsiniz. Biz bu örnekte tek bir rota üzerinden ilerleyeceğiz.

Ardından tests structumu oluşturuyorum. Burada olmazsa olmazlarımız name, description ve want fieldlarıdır. Ben daha dinamik olması adına endpoint ve payload isimli iki field daha ekliyorum. 

Sonraki aşamada bu structun içeriğini oluşturmamız gerekiyor. Bu aşamada iki adet test oluşturuyorum. Birinde başarılı şekilde gönderimin oluşturulup, 200 status code döndürmesini ve JSON’u unmarshal ettiğimde istediğim keylerin bulunup bulunmadığını test ediyorum. Normal şartlarda gönderimin oluşturulup id, title ve content döndürmesi gerektiğini biliyorum.

İkinci testimde ise uygulamam content kısmının boş olmasını kabul etmeyip 400 döndürüyor. Ben de bunun gerçekten istenilen şekilde çalışıp çalışmadığını kontrol etmek için boş contente sahip bir gönderi oluşturtuyorum. Ardından 400 status code dönmesini ve dönen içerikte de sadece message alanının olmasını bekliyorum.

Testlerimi tanımladığıma göre artık gerçek kontrolleri yapmaya başlayabiliriz. for döngüsü ile testlerimi çalıştırmaya başlıyorum. Test kontrol koşullarımı t.Run() fonksiyonu içerisinde yazacağım. 
İlk aşamada test payloadımın marshal edilip edilemediğini kontrol ediyorum. Bu aşama gerçekleşmezse diğer aşamalarda ilerlenmesinin bir anlamı olmadığından t.Fail() diyerek testi anında sonlandırıyorum.

Ardından handlerımı test etmek için bir HTTP requesti göndermem lazım. Bunu da inbuilt gelen httptest kütüphanesi ile gerçekleştiriyorum. Yeni bir post requesti oluşturup endpointi ve payloadımı ekliyorum. Payloadımın application/json olduğunu belirtmem fiber için çok önemli. Aksi takdirde bodyParser içeriğimizi kullanamayacaktır.

Requesti oluşturduktan sonra app.Test(req) diyerek fiber içerisinde gelen test fonksiyonu ile çalıştırıyorum. Çalıştırdıktan sonra ilk aşamada beklediğim status code gelmiş mi diye kontrol ediyorum.
Bu aşamadan sonra da gelen içeriği parse edip gerekli keyler var mı diye kontrol ettikten sonra testimi sonlandırıyorum.

VSCode üzerinde Go eklentisi kurulu olduğunda testleri bu kısımdan kolayca görüntüleyip çalıştırabiliyoruz.

Yazdığım testlerin bulunduğu kodlara şu repodan ulaşabilirsiniz: go-rest-api-boilerplate/app/controllers/post at main · dogukanoksuz/go-rest-api-boilerplate (github.com)

Okuduğunuz için teşekkür ederim. Sorularınız ve geri bildirimleriniz için aşağıdaki yorum bölümünü kullanabilirsiniz. İyi kodlamalar <3

Bugün Golang ile Gofiber kullanarak yüksek performanslı bir REST API nasıl geliştirilir bunun üzerine konuşacağız. 

Gofiber framework kullanmamızın sebebini şu şekilde listeleyebiliriz:

• Yüksek performans ve düşük bellek kullanımı
• Hızlı server-side programlama
• Kütüphane tarafından sağlanan middlewarelar
• Kolay rotalama

Proje Oluşturma

Genel olarak konuya giriş yaptığımıza göre Go projemizi oluşturarak devam edebiliriz. Boş bir Go projesi oluşturmak için şu işlemleri yapalım.

$ mkdir restapi

$ go mod init github.com/USERNAME/REPO_NAME

Bu işlemleri yaptıktan sonra gerekli klasörler ve dosyalar oluşacaktır. Şimdi proje dizinimizde main.go dosyamızı oluşturalım, ardından gofiber kütüphanesini projemize aşağıdaki komut ile ekleyelim.

$ go get github.com/gofiber/fiber/v2

Klasör Yapısı

/app

Bu klasör bizim genel Fiber uygulamamıza dair fonksiyonları barındırmalıdır. Şu şekilde kapsamlandırabiliriz.

• controllers
  Rotalarda kullanılacak controllerları burada tanımlarız.
• models
  Uygulamamızdaki modelleri bu klasör altında oluşturmalıyız.
  

/pkg

• configs
  Bu klasörde uygulamamıza ait konfigürasyon dosyalarını tutabiliriz.
• middleware
  Bu klasörde fiber uygulamamız için gerekli middlewareları oluşturabiliriz.
• routes
  Bu klasör içerisinde projemize ait rotaları tutabiliriz.
• utils
  Bu klasörde sunucumuzu başlatan, hataları kontrol eden veya uygun gördüğümüz dosyaları oluşturabiliriz.

/platform

• cache
  Bu klasörde kullanacağımız önbellekleme çözümünü implemente edebiliriz.
• database
  Veritabanı bağlantılarını ve diğer işlemleri yapacağımız kısım.
• migrations
  Migrationları oluşturacağımız klasör
  
  

Fiber Sunucusu

Bunun için öncelikle pkg/utils altında server.go dosyamızı oluşturalım ve içeriğini aşağıdaki şekilde ekleyelim.

package utils

import (
    "fmt"
    "log"

    "github.com/gofiber/fiber/v2"
)

func CreateServer(port int) {
    // Create Fiber App
    app := fiber.New()

    // Start server
    log.Fatal(app.Listen(fmt.Sprintf(":%d", port)))
}

Ardından bu fonksiyona bir port değişkeni vererek main.go içerisinde şu şekilde çağırabiliriz.

Bu fonksiyon içerisinde middlewarelarımızı ve rotalarımızı kaydedeceğiz.

Örnek main.go içeriği:

package main

import "github.com/dogukanoksuz/go-rest-api-example/pkg/utils"

func main() {
    utils.CreateServer(3000)
}

Model Oluşturmak

Genel olarak projemizin klasör yapısından bahsettiğimize göre bu tarz bir yapıyı oluşturalım. 

Ardından models klasörümizin içerisinde ilk modelimizi oluşturalım. Ben post yani gönderi isminde bir model oluşturacağım. Dosya içeriğini aşağıdaki gibi tanımlayabiliriz.

package models

import (
    "github.com/google/uuid"
    "gorm.io/gorm"
)

type Post struct {
    ID      string `gorm:"primary_key"`
    Title   string
    Content string `gorm:"type:text"`
}

func (post *Post) BeforeCreate(tx *gorm.DB) error {
    post.ID = uuid.NewString()
    return nil
}

Oluşturduktan sonra ilk modelimiz hazır. Genel olarak detaylarından bahsetmek gerekirse ID alanı için UUID oluşturuyoruz. Bunun için de GORM’un pre-hooklarından faydalanarak bir UUID tanımlıyoruz. 

Veritabanı Bağlantısı

Öncelikle kendi ortamınızda bir veritabanı sunucusuna sahip olmanız gerekmektedir. Ben devilbox kullanarak bir MariaDB instanceı oluşturdum. Siz de benzer programlarla veritabanınızı oluşturun.

Bu işlemin ardından platform/database klasörü altında mysql.go isminde bir dosya oluşturun.

package database

import (
    "fmt"
    "os"

    "gorm.io/driver/mysql"
    "gorm.io/gorm"
)

var Conn *gorm.DB

func Init() error {
    var err error

    dsn := fmt.Sprintf(
        "%s:%s@tcp(%s:%s)/%s?charset=utf8mb4&parseTime=True&loc=Local",
        "DB_USER",
        "DB_PASS",
        "DB_HOST",
        "DB_PORT",
        "DB_NAME",
    )

    Conn, err = gorm.Open(mysql.Open(dsn), &gorm.Config{})

    if err != nil {
        return err
    }

    return nil
}

Yukarıdaki şekilde tanımlama yaptıktan sonra DB_USER gibi boşlukları kendi veritabanı bilgileriniz ile değiştirin. Ardından database.Init() şeklinde server.go dosyanız içerisinde çağırımı yaparak sunucu başlamadan önce veritabanı bağlantınızı açabilirsiniz.

Migrationlar

Migration işlemi oluşturduğumuz modellerin otomatik şekilde veritabanında tablolarının eklenmesi işlemidir. Bunun için platform/migrations altında migrate.go isminde bir dosya oluşturalım ve içeriğini aşağıdaki şekilde girelim.

package migrations

import (
    "github.com/dogukanoksuz/go-rest-api-example/app/models"
    "github.com/dogukanoksuz/go-rest-api-example/platform/database"
)

func Migrate() {
    database.Conn.AutoMigrate(&models.Post{})
}

Bu kısımdaki AutoMigrate fonksiyonu GORM’un içerisinde gelen bir fonksiyondur. Diğer oluşturduğunuz modeller (varsa) bu kısımda tanımlayarak uygulama başlangıcında tablolarının oluşturulmasını sağlayabilirsiniz. Bu fonksiyonu CreateServer fonksiyonu altında database.Init fonksiyonundan hemen sonra çağırabiliriz.

Kontrolcü Oluşturmak

Kontrolcüler projemizin önemli bir ayağını oluşturmaktadır. Fiber tarafında ismi Handler olarak geçmektedir ve rotalarımızın ucunu bağladığımız Go fonksiyonlarına kontrolcü demekteyiz. Kontrolcüler bizim için postlarımızı listeleme, oluşturma, güncelleme ve silme işlemlerini yapabilir.

GORM ve Fiber kullanarak listeleme ve oluşturma işlemlerini örnek olarak inceleyelim.

Oluşturma (Create)

package post

import (
    "github.com/dogukanoksuz/go-rest-api-example/app/models"
    "github.com/dogukanoksuz/go-rest-api-example/platform/database"
    "github.com/gofiber/fiber/v2"
)

func Create(ctx *fiber.Ctx) error {
    post := models.Post{}

    if err := ctx.BodyParser(&post); err != nil {
        return ctx.Status(503).JSON(err)
    }

    if err := database.Conn.Create(&post).Error; err != nil {
        return ctx.Status(503).JSON(err)
    }

    return ctx.JSON(post)
}

Bu dosyayı app/controllers/post/create.go olarak oluşturalım ve inceleyelim. Öncelikle Fiber’ın BodyParser fonksiyonunu kullanarak bodyden gelen JSON’u parse edelim. Ardından database.Conn.Create diyerek girdimizi veritabanına ekleyelim. İşlemlerin sonunda da kullanıcıya JSON olarak oluşturulan gönderimizi gönderebiliriz.

Listeleme (Index/List)

package post

import (
    "github.com/dogukanoksuz/go-rest-api-example/app/models"
    "github.com/dogukanoksuz/go-rest-api-example/platform/database"
    "github.com/gofiber/fiber/v2"
)

func Index(ctx *fiber.Ctx) error {
    posts := []models.Post{}
    database.Conn.Find(&posts)

    return ctx.JSON(posts)
}

GORM ile bir modelin girdilerini listelemek istediğimizde yukarıdaki yola başvurabiliriz. Find fonksiyonu bizim için tüm postları getirecektir ve bunu da kullanıcılara JSON olarak döndürebiliriz.

Rota Tanımlamak

Rotalar REST sunucumuzda hangi uçların hangi fonksiyonları çağıracağını, alacağı parametreleri vb. tanımladığımız yerdir. Gelin örnek olarak yukarıdaki iki fonksiyonun rotalarını tanımlayalım.

Bunun pkg/routes altında post.go dosyamızı oluşturabiliriz. Bu dosyanın içeriği aşağıdaki gibi olmalıdır.

package routes

import (
    "github.com/dogukanoksuz/go-rest-api-example/app/controllers/post"
    "github.com/gofiber/fiber/v2"
)

func PostRoutes(app *fiber.App) {
    // List All Posts
    app.Get("/posts", post.Index)

    // Create Post
    app.Post("/post", post.Create)
}

Bu PostRoutes fonksiyonumuzu da CreateServer altında fiber app oluşturduktan hemen sonra çağırabiliriz. routes.PostRoutes(app) şeklinde tanımlamayı yaptığımızda rotalarımız kullanıma hazır olacaktır.

Derleme ve Denemeler

Projeyi çalıştırmak için go run main.go şeklinde başlatabilir ya da go build diyerek oluşan executable’ı çalıştırabiliriz.

Temel olarak oluşturduğunuz REST API’ı derleyip denemeler yapın. Bunun için Postman programını veya sevdiğiniz bir REST clienti kullanabilirsiniz.

Rotalarınıza 127.0.0.1:3000/posts şeklinde erişebilirsiniz. Eğer veritabanında girdi oluşturulmuş ise başarılı şekilde dönüşümüzü alacağız.

Tamamlanmış Proje

dogukanoksuz/go-rest-api-boilerplate: Golang REST API Boilerplate with Gofiber (github.com) altından projenin tamamlanmış haline ulaşabilirsiniz. Post modeli için tüm CRUD işlemlerinin tamamlandığı örnek bu şekilde incelenebilir.

Okuduğunuz için teşekkür ederim. Problemler için GitHub reposu içerisinde issue oluşturabilir veya aşağıdaki yorumlar bölümünü kullanabilirsiniz.

Bugün Golang kullanarak bir CLI uygulaması (konsol) nasıl geliştirebileceğimizden bahsedeceğim. Bir konsol uygulaması ne diye soracak olursanız şunları örnek verebiliriz. Systemctl, docker... gibi bir çok örneği mevcuttur. 

Golang nedir?

Golang, basit, güvenli ve verimli yazılımlar geliştirmemize olanak tanıyan açık kaynaklı bir programlama dilidir. Google tarafından desteklenmektedir. Derlenebilir bir dil olduğundan yüksek performans sunmaktadır. Paket yönetimi sistemi, hızlı derleme süresi büyük artılarındandır. Derlenen programların çalıştırılması için bir VM'e ihtiyaç duyulmamaktadır. (Java'daki bytecode runner örnek verilebilir)

Yeni bir Golang projesi oluşturmak

Golang kurulumu

Öncelikle sistemimize Go kurulumu yapmamız gerekmektedir. Derleme işlemlerini kendi içindeki araçlar ile yapacağız. Arch Linux’da pacman -S go, Pardus/Debian üzerinde ise apt install golang yazarak kurulum işlemlerini gerçekleştirebiliriz. Kurulduğundan emin olmak için ise terminalimizde go version komutunu çalıştırarak kurulumun gerçekleştiğinden emin olalım.

Yeni proje oluşturmak

Yeni proje oluşturmak için ev dizinimizde go isimli bir klasör oluşturuyoruz. Ardından içine de src isimli bir klasör oluşturuyoruz. Bu klasör içerisinde projelerimizi oluşturacağız. İlk aşama olarak src klasörü içerisinde GitHub hesap isminiz ile klasör oluşturmalısınız. Bu senaryoda benim dogukanoksuz isimli bir klasör oluşturmam gerekmekte. Bu işlemlerin sonunda artık klasörümüz içerisine istediğimiz isimle projelerimizi oluşturabiliriz. Örnek olarak go-cli-application isminde bir klasör açalım ve terminalde bu dizine geçiş yapalım.

$ go mod init github.com/GITHUB_HESAP_ADINIZ/go-cli-application

komutunu çalıştıralım. Bu komut sayesinde projemizde Go paket yöneticisini kullanabileceğiz.

Code eklentisi kurulumu

Eklentiler sekmesinden Go diye arattığımızda bu eklentinin kurulumunu yapıp Quick Start kısmını takip etmeliyiz. İşlemin ardından Go ortamınız otomatik formatlama, hata gösterme ve tamamlama gibi özellikleri alacaktır. Tavsiye ettiğim geliştirme ortamı bu şekildedir.

CLI uygulamasının temellerini atmak

Öncelikle kodlarımızın başlangıç noktası olan main dosyamızı oluşturmamız gerekmektedir. Klasörümüz içerisinde main.go dosyasını oluşturalım. Ardından içeriği aşağıdaki gibi olmalıdır.

package main

func main() {
    // Uygulamamızın başlangıç noktası
}

Şu adımda bir Go projesi oluşturmuş olduk. Eğer bir Hello world mesajı görmek isterseniz fmt.Println("Hello world") şeklinde çağrımızı yapabiliriz.

Uygulamamızı derlemek için de go run main.go veya go build komutlarını çalıştırabiliriz. Ardından klasörümüz içerisinde çalıştırılabilir dosyamız oluşacaktır.

Bu aşamadan sonra bir CLI uygulaması geliştirmek için tüm hazırlıklarımızı tamamladık. Şimdi işimizi kolaylaştıracak bir kütüphane kurulumu yapalım.

spf13/cobra adresinden dokümanını inceleyebileceğimiz Cobra kütüphanesini şu komut ile kuracağız. 

$ go get -u github.com/spf13/cobra 

komutunu çalıştırarak kütüphanemizi projeye ekleyelim.

Cobra kütüphanesi kullanımı

Argümanların yakalanması, parse edilmesi işlemlerini bizim yerimize kolayca halletmesi için Cobra kütüphanesini kullanacağız.

▾ go-cli-application/
    ▾ cmd/
        buraya.go
        komutlarinizi.go
        ekleyin.go
        root.go
      main.go

Klasör yapımız yukarıdaki şekilde olmalıdır. Komutlarımızı cmd klasörü altında açacağız. main.go dosyasının içeriğini de aşağıdaki gibi değiştirelim.

package main

import (
  "github.com/GITHUB_KULLANICI_ADINIZ/go-cli-application/cmd"
)

func main() {
  cmd.Execute()
}

Cobra kütüphanesi artık tüm argümanları yakalayacaktır. Gelin birlikte kök komutumuzu oluşturalım. cmd klasörü içine root.go dosyamızı oluşturalım.

package cmd

import (
    "fmt"
    "os"

    "github.com/spf13/cobra"
)

var (
    rootCmd = &cobra.Command{
        Use:   "go-cli-application",
        Short: "Example Go CLI Application",
        Long:  `Example Go CLI Application`,
    }
)

func Execute() {
    if err := rootCmd.Execute(); err != nil {
        fmt.Fprintln(os.Stderr, err)
        os.Exit(1)
    }
}

func init() {
    rootCmd.CompletionOptions.DisableDefaultCmd = true
}

rootCmd değişkenimiz içerisinde bir cobra.Command türünde struct tanımlıyoruz. Bu struct içerisinde uygulamamız çalıştırıldığında yardım sayfasında çıkacak mesajlar vb. düzenlenmektedir.

Execute() fonksiyonu ise Cobra uygulamamızın çalışmasını sağlayan kod bloğudur.

init fonksiyonunda da uygulama her çalıştırıldığında yapılacak işlemler tanımlanacaktır.

Gelin bir de ilk komutumuzu ekleyelim.

package cmd

import (
    "fmt"

    "github.com/spf13/cobra"
)

func init() {
    rootCmd.AddCommand(exampleCmd)
}

func example() {
    fmt.Println("My example output")
}

var (
    exampleCmd = &cobra.Command{
        Use:   "example",
        Short: "Example command",
        Long:  "Example command",
        Run: func(cmd *cobra.Command, args []string) {
            example()
        },
    }
)

Yukarıda görüldüğü üzere exampleCmd değişkeninin içeriğine bir de Run diye bir anahtar ekledik. Bu Run anahtarı komut çalıştırıldığında yürütülecek fonksiyon(ları) eklediğimiz ve argümanları yakaladığımız kısım. Ben örnek olarak example fonksiyonunu çağırmasını istedim.

Example fonksiyonunda ise "My example output" diye bir çıktı verdim.

Ardından komutun Cobra sistemine eklenebilmesi için init fonksiyonum içinde rootCmd içerisine addCommand fonksiyonunu kullanarak ekledim.

Şimdi denemek için go build komutunu çalıştırıyorum ve klasörümüz içerisinde go-cli-application diye bir çalıştırılabilir dosya oluştu. Bu dosyayı çalıştırdığımda yardım sayfası görünecek, go-cli-application example diye çalıştırdığımızda ise fonksiyonumuz çalışacaktır.

Temel olarak bir Go CLI uygulaması bu şekilde oluşturulabilir. Geri kalanı sizin yaratıcılığınıza kalmış, ister veritabanına bağlanıp çeşitli sorgular çalıştıran bir uygulama, isterseniz sistem dosyalarını değiştiren bir program yazabilirsiniz.

Sorularınız için yorum bölümünü kullanabilirsiniz. İyi çalışmalar dilerim :)

Pardus işletim sistemi için daha önce WSL programı oluşturulmadığını gördüm ve bu sebepten ötürü Pardus işletim sistemini WSL paketi haline getirdim. Bu işlem için Microsoft'un WSL-DistroStarter paketini kullanarak özel bir exe derledim.

WSL'i daha önce kullanmadıysanız ya da kurmadıysanız WSL2 ile Windows Üzerinde Linux Kullanmak isimli makalemi okuyarak temel bilgileri edinebilir, nasıl kuracağınızı öğrenebilirsiniz. Şimdi Pardus WSL nasıl kurulur onu anlatalım.

Öncelikle Releases · dogukanoksuz/PardusWSL (github.com) adresinden Pardus.exe ve install.tar.gz dosyasını indirip aynı klasöre koyunuz. Klasörün dosya izinlerinin doğru olduğuna emin olunuz. Masaüstünüz veya C:\ diskinizin ana dizini elverişli olabilir. 

Yukarıda gördüğünüz şekilde yerleştirdiyseniz Pardus.exe dosyasını çalıştırabilirsiniz.

Yukarıdaki mesajı gördüğünüzde işlemin bitmesini bekleyiniz, biraz sürecektir.

Kullanıcı adınız ve şifreniz sorulacak, onları oluşturduktan sonra WSL 1 sürümünden WSL 2 sürümüne yükseltmemiz gerekiyor.

Gördüğünüz üzere wsl --set-version Pardus 2 komutunu yazarak WSL 2 yükseltme işlemini başarıyla tamamladım. WSL 2 daha stabil bir kullanım sunmaktadır. 

Sonrasında kurduğumuz dağıtıma ulaşmak için Pardus.exe dosyasını çalıştırabiliriz veya Microsoft Store üzerinden Windows Terminal kurulumu yapabilirsiniz. İşlem bittikten sonra aşağıdaki şekilde sorunsuz Pardus işletim sistemini kullanabilirsiniz.

Eğer bir problem görürseniz GitHub reposu üzerinde issue açarsanız çözmeye çalışırım. Okuduğunuz için teşekkür eder, iyi çalışmalar dilerim.

13.05.2021 Güncelleme:

Locale hatasının çözümü için aşağıdaki yolu takip edebilirsiniz.

/etc/default/locale dosyasını sudo ile açıp içeriğini aşağıdaki ile değiştirin:

LC_CTYPE="en_US.UTF-8"
LC_ALL="en_US.UTF-8"
LANG="en_US.UTF-8"

ve şu komutu kullanın:

sudo dpkg-reconfigure locales

ve aşağıdaki komutla WSL'i yeniden başlatın:

wsl.exe --shutdown

Laravel 8 üzerinde bildiğiniz üzere gelen hazır bir auth paketi mevcut. Bu auth paketi üzerinde rollere göre giriş sonrası panelleri değiştiremiyoruz. Bunun için kodlarda değişiklik yaparak projemizi uygun hale getirmemiz gerekmektedir.

Laravel projesi nasıl oluşturulur?

İlk önce Laravel projemizi oluşturmamız gerekmektedir. Bu işlem için aşağıdaki komutları terminalden çalıştırabilirsiniz.

$ curl -s https://laravel.build/example-app | bash

example-app kısmı yerine kendi uygulama isminizi yazabilirsiniz. Projeniz o şekilde oluşacaktır. Ardından Laravel Breeze yani temel auth paketini ekleyelim. Bunun için composer’a ihtiyacımız var.

$ composer require laravel/breeze –dev

Bu komutun ardından breeze paketimizi sisteme ekledik ancak kurulum halen bitmedi. Şu komutları da giriyoruz. Tabii ki öncesinde .env dosyanızı veritabanına bağlamayı unutmayınız. Eğer sisteminizde MySQL/MariaDB kurulumu mevcut değil ise sitemdeki Devilbox kurulumu makalesine bakabilir veya Laravel Sail kullanımını araştırabilirsiniz.

$ php artisan breeze:install
$ npm install
$ npm run dev
$ php artisan migrate

Bu kurulumları yaptıktan sonra Laravel uygulamamızda sorunsuz şekilde /register, /login gibi rotaların otomatik tanımlandığını göreceksiniz.

Laravel ile kullanıcı tiplerini ayırmak

Kullanıcılarımızın tiplerini veritabanı üzerinde belirleyelim. Doğru yol bu olmasa da ben anlatımda anlaşılır ve kolay olması için direkt users tablosu üzerine ekleme yapacağım ancak optimal yol farklı bir tablo üzerinde user_roles tarzı bir tablo oluşturup model üzerinden çağırma işlemini yapmaktır. Bu yol ile default entryler için ekstradan bir sütun oluşturmamış olacaksınız.

Users tablosuna ben user_type isminde bir kısım ekledim. Database/migrations klasörünüz altından users dosyanızı bulunuz ve password altına aşağıdaki kod satırını ekleyiniz.

$table->string('user_type')->default('customer');

Benim sistemimde customer, booster ve superuser tipinde üç kullanıcı olacağı için default kısmını customer olarak tanımladım. Siz bu tipleri projeniz için kendinize göre belirlemelisiniz. Bu migration değişikliği sonrası şu komutu çalıştırın.

$ php artisan migrate:refresh

Şimdi rotalarımızı oluşturmamız gerekiyor. Ben şu şekilde oluşturmayı tercih ettim.

Route::get('/customer', function () {
    return view('dashboard');
})->middleware(['auth'])->name('customer');

Route::get('/booster', function () {
    return view('dashboard');
})->middleware(['auth', 'role:booster'])->name('booster');

Route::get('/superuser', function () {
    return view('dashboard');
})->middleware(['auth', 'role:superuser'])->name('superuser');

Gördüğünüz üzere kodlarımızda roller için özel bir middleware tanımlamışım. Hemen oluşturalım.

$ php artisan make:middleware CheckIfHasRole

Oluşan dosyamızın içeriğini aşağıdaki gibi tanımlayalım.

public function handle(Request $request, Closure $next, $type)
{
        if (auth()->check() && auth()->user()->user_type == "superuser") {
            return $next($request);
        }

        if (auth()->check() && auth()->user()->user_type == $type) {
            return $next($request);
        }

        return redirect(route('index'))->withErrors([$type. ' erişiminiz yok.', 'Kullanıcı: ' . auth()->user()->id]);
}

Ardından App/Http/Kernel.php dosyamızı açalım. $routeMiddleware değişkenine yeni bir key, value ekleyelim.

'role' => \App\Http\Middleware\CheckIfHasRole::class,

Bu işlemi yaptıktan sonra rotalarımızın sorunsuz çalıştığından emin olalım. Denediğinizde bir problem olmaması gerekiyor. Şimdi login olduğumuzda her seferinde /dashboard altına giriş yapmaya çalıştığını farkedeceksiniz. Bunu da düzeltmemiz gerekiyor. Bunun için App/Providers/RouteServiceProvider.php dosyasını açalım.

Bu dosya içerisinde şu satırın altına kendi fonksiyonumuzu yazacağız.

public const HOME = '/customer';

public static function redirectTo() {
        if (auth()->user()->user_type == "booster") {
            return "/booster";
        }

        if (auth()->user()->user_type == "superuser") {
            return "/superuser";
        }

        return "/customer";
}

Şeklinde fonksiyonumuzu ekleyelim. Bu fonksiyon rollerimize göre yönlenmemiz gereken adresleri düzenleyecek. Şimdi fonksiyonu işleme sokmak için App/Http/Controllers/Auth altındaki tüm dosyalarda RouteServiceProvider::HOME yerine RouteServiceProvider::redirectTo() yazmamız gerekmekte. Bu değişiklik için VSCode ile projenizde home değişkenini aratıp hepsini redirectTo() ile değiştirmesini sağlayabilirsiniz.

Bu işlemlerin hepsini doğru şekilde yaptığınızda Laravel 8 üzerinde kullanıcı tiplerinin girişini birbirinden ayırmış olacaksınız. Sorularınız için yorum bölümünü kullanabilirsiniz.

Merhaba, kendi websitemi de oluşturduğum CSS frameworkü TailwindCSS’yi kurmak ve konfigüre etmek biraz zor. Bu sebeple taban (starter) proje oluşturmayı göstermek için bir makale yazmak istedim. Öncelikle TailwindCSS nedir bilmeyen dostlarımız için o kısma değinelim.

TailwindCSS Nedir?

TailwindCSS Laravel ekibinden insanların gönüllü olarak geliştirdiği açık kaynaklı bir CSS yardımcı araç kitidir. Bootstrap ve Foundationdan farklı olarak UI kit değildir, komponent bazlı değildir. Yardımcı classları kullanarak komponentleri sizin geliştirmeniz beklenmektedir. Örnek olarak şu an websitemin kaynak kodlarını incelerseniz TailwindCSS baz classları kullanarak oluşturulduğunu görürsünüz. HTML/CSS konusuna hakim olan dostlarım zaten kodları gördüğünde olayı anlayacaktır.

TailwindCSS Projesi Nasıl Oluşturulur?

İlk önce klasör oluşturup npmi başlatmalıyız, ardından gereken paketleri development ve main branch olarak ayırarak kurulumunu gerçekleştirmeliyiz.

$ mkdir tailwindstarter
$ npm init
$ npm install tailwindcss@latest postcss@latest autoprefixer@latest
$ npm install -D concurrently@latest cross-env@latest cssnano@latest live-server@latest postcss-cli@latest

Bu adımlardan sonra postcss.config.js dosyamızı oluşturuyoruz ve içeriğini aşağıdaki gibi yapıyoruz.

$ nano postcss.config.js

module.exports = {
  plugins: [
    require("tailwindcss"),
    require("autoprefixer"),
    ...(process.env.NODE_ENV === "production" ? [require("cssnano")] : []),
  ],
};

Bu dosyayı oluşturduktan sonra aşağıdaki komutu girerek tailwind config dosyamızı oluşturuyoruz.

$ npx tailwind init

Ardından tailwind.config.js dosyamızın içeriğini aşağıdakine uygun olarak düzenleyelim.

module.exports = {
  purge: [
    './public/**/*.html',
  ],
  darkMode: false, // or 'media' or 'class'
  theme: {
    extend: {},
  },
  variants: {
    extend: {},
  },
  plugins: [],
}

Bu adımda kendi dosyanızda büyük ihtimalle purge kısmını sizinkinden farklı göreceksiniz. Bu kısmın sebebi PostCSS preprocessor kullandığımızdan production buildi aldığımızda kullanmadığımız classların çıkarılmasını sağlayacaktır. Örnek kullanımı aynı şekilde kendi sitemdeki build.css dosyasını görüntüleyerek görebilirsiniz. Tailwind salt hali ile 2-3 MB arası bir boyuttayken sitemde production build sonrası 46kB boyutuna düşmüştür.

Bu işlemlerin ardından yaptığımız işlemler dışında aşağıdaki klasör yapısını oluşturalım.

├── package.json
├── package-lock.json
├── postcss.config.js
├── public
│   └── index.html
├── src
│   ├── css
│   │   └── app.css
│   └── js
│       └── app.js
└── tailwind.config.js

Klasör yapımızı bu hale getirmemizin sebebi src klasörü içerisinde css ve javascript dosyalarımızın birlikte derlenmemiş hali bulunmasıdır. Public klasörümüz içerisine dosyamızda değişiklik yaptıkça sürekli otomatik olarak development buildi derlenecektir.

src/css içerisinde oluşturduğunuz app.css dosyasını açın ve içeriğini aşağıdaki ile değiştirin. Bu değişiklik sayesinde Tailwind kütüphanesinin stillerini projenize ekleyeceksiniz.

@tailwind base;
@tailwind components;
@tailwind utilities;

Son olarak projemizi nasıl çalıştıracağız dediğinizi duyar gibiyim. package.json dosyamızı düzenleyip çalıştırma scriptlerimizi girelim ve kolay şekilde projemizi tekrar tekrar çalıştırabilelim.

"scripts": {
    "serve": "cross-env NODE_ENV=development concurrently \"postcss src/css/app.css -o public/css/build.css --watch\" > "development": "cross-env NODE_ENV=development postcss src/css/app.css -o public/css/build.css",
    "production": "cross-env NODE_ENV=production postcss src/css/app.css -o public/css/build.css"
},

Burada eklediğiniz kodda live browser edit ile kullanmak için npm run serve, production buildi alabilmek için ise npm run production yazmanız gerekmektedir.

Starter projesini bu kadar uğraşmadan kullanmak istiyorsanız makaleyi hazırlarken oluşturduğum hazır halini github adresime ekledim. dogukanoksuz/tailwind-starter: TailwindCSS + PostCSS Starter Pack (github.com) adresinden ulaşabilirsiniz.

Sorularınız için aşağıdaki yorum bölümünü kullanabilirsiniz. Okuduğunuz için teşekkür ederim.

BIOS ayarlarınız doğru mu?

Bios üzerinden ayarlarınızı kontrol ediniz. VT-d, VT-x ve Virtualization Technology ayarlarının aktif hale getirilmesi gerekmektedir. Aksi halde WSL2 başlamayacaktır.

Windows özelliklerini kontrol edin

Windows Features veya Windows özellikleri diye adlandırabileceğimiz kısımdan ayarlarınızı kontrol ediniz. Virtual Machine Platform, Windows Hypervisor Platform ve Windows Subsystem for Linux seçeneklerinin işaretli olduğuna emin olunuz.

VMware ürünleri sisteminizde kurulu mu?

Eğer sisteminizde VMware ürünleri kurulu ise şu anda bilinen bir çakışma söz konusu. Yukarıdaki adımları kontrol ettikten sonra bu adıma dönün ve sisteminizdeki VMware ürünlerini kaldırmayı deneyiniz.

Windows Docker Desktop Kurulumu

Öncelikle bu adresten Docker Desktop for Windows programını indirelim. Ardından kurulum işlemini yapalım -kısaca tüm seçeneklere next diyebilirsiniz, adware/düzenlenmesi gereken ayar bulunmamakta-.

Docker Desktop WSL2 Ayarları

Ayarları yapabilmek için öncelikle Docker Desktop uygulamasını açınız. Sağ alttaki balina logosuna sağ tıklayıp Dashboard seçeneğini seçiniz. Aşağıda gösterilen ayarları sırası ile yapınız.

Uygulamamızı açtıktan sonra ayarlar simgesine tıklayalım. Ardından General menüsü altından Use the WSL 2 based engine seçeneğini seçelim. 

Resources menüsüne tıklayalım. Buradan WSL INTEGRATION seçeneğini seçelim. Çıkan ayarlardan "Enable integration with my default WSL distro" seçeneğini işaretleyip alttaki distrolar için gereken tikleri aktif hale getirelim. 

Bu işlemleri tamamladıktan sonra Apply & Restart düğmesine tıklayarak ayarlarımızı kaydedelim. Docker Desktop yeniden başlayacaktır. Bu işlemin ardından kontrol edebilirsiniz. Gelin beraber bakalım.

Çalışıyor mu deneyelim 😊

Gördüğünüz gibi öncesi sonrası farkını görmüş olduk. Sorularınızı yorum bölümünden yöneltebilirsiniz. İyi çalışmalar dilerim.

Cliente mesaj gönderme işlemi

socket.emit('hello', 'can you hear me?', 1, 2, 'abc');

Tüm clientlere gönderim yapmak

socket.broadcast.emit('broadcast', 'hello friends!');

Game isimli odadaki tüm clientlere gönderim yapmak

socket.to('game').emit('nice game', "let's play a game");

Game1 ve/veya Game2 odasındaki tüm clientlere gönderim yapmak

socket.to('game1').to('game2').emit('nice game', "let's play a game (too)");

Game odasındaki tüm clientlere gönderici dahil gönderim yapmak

io.in('game').emit('big-announcement', 'the game will start soon');

myNamespace namespacei içerisindeki herkese gönderici dahil gönderim yapmak

io.of('myNamespace').emit('bigger-announcement', 'the tournament will start soon');

Bir namespace içerisindeki odaya gönderici dahil gönderim yapmak

io.of('myNamespace').to('room').emit('event', 'message');

Eğer biliyorsanız socketId ile gönderim yapmanızı sağlar (özel mesaj için kullanılabilir)

io.to(socketId).emit('hey', 'I just met you');

DİKKAT: io.to yerine socket.to yazarsanız çalışmayacaktır ve odadaki herkese gönderim yapacaktır. Ne yaptığınızdan eminseniz kullanın.

Dönüş alabildiğiniz mesaj gönderimi yapmak

socket.emit('question', 'do you think so?', function (answer) {});

Sıkıştırma olmadan gönderim yapmak

socket.compress(false).emit('uncompressed', "that's rough");

Eğer client mesaj almaya hazır değilse geçici mesajlar göndermek

socket.volatile.emit('maybe', 'do you really need it?');

Node üzerindeki tüm clientlere gönderim yapmak (eğer çoklu socket kullanıyorsanız)

io.local.emit('hi', 'my lovely babies');

Sunucuya bağlı tüm clientlere mesaj gönderimi yapmak

io.emit('an event sent to all connected clients');

Socket.IO nedir?

Websocket altyapısı kullanan ancak websocket olmayan bir realtime enginedir. Tüm dillere community tarafından entegre edildiğinden ve esnek kullanım sağladığından modern altyapılar için kullanımı uygundur.

Socket.IO iki yönlü, canlı zamanlı ve olaylar üzerine çalışan bir iletişim sağlar. Her platformda, tarayıcıda veya cihazda güvenilirlik ve hız olarak eşitliği gözetir.

Socket.IO’ya başlangıç

Öncelikle socket sunucumuzu oluşturarak başlamalıyız. Bu işlemi yapmak için bir klasör oluşturun içine gidin ve ardından “npm init” komutunu çalıştırınız, sorulan soruları istediğiniz şekilde yanıtlayarak projenizi oluşturun. Ardından gereken bağımlılıkların kurulumunu yapmamız gerekmekte. Bu işlem için girmemiz gereken komut:

npm install express socket.io node-fetch xml2js

Bu komutun ardından express, socket.io, fetch ve xml2js kurulumu gerçekleşecektir. Makalemizde döviz kurlarını 5 saniyede bir yenileyen bir proje oluşturacağız.

Klasörünüz içerisinde index.js dosyasını oluşturunuz ve içeriğini bu şekilde giriniz.

const express = require("express")
const fetch = require("node-fetch")
const xml = require('xml2js').parseString
const app = express()
const http = require("http").createServer(app)
const io = require("socket.io")(http)
const ZAMAN = 5000

var Data

let fetchCurrency = async () => {
    try {
        let response = await fetch('https://www.tcmb.gov.tr/kurlar/today.xml')
        let text = await response.text()
        xml(text, (e, output) => {
            Data = output.Tarih_Date.Currency[0]
        })
    } catch (e) {
        console.log(e)
    }
}

let currencyPoller = async () => {
    await fetchCurrency()
    setTimeout(async () => {
        await fetchCurrency()
        console.log(`Sunucuda data yenilendi.`)
        currencyPoller()
    }, ZAMAN);
}

currencyPoller()

http.listen(3000, () => {
    console.log(`I'm alive!`)
})

Öncelikle bu kodlarda ne yaptığımızdan bahsedelim. Başlangıçta paketlerimizi require ettik ve ne kadar sürede bir yayın yapacağımızı bir sabit değişken ile belirttim. Ardından her kullanıcı için verinin ayrı şekilde stream edilmesini istemediğimden ötürü global bir değişken oluşturdum. fetchCurrency fonksiyonumuzda ise TCMB sunucularından XML verisini alıp bunu JSON’a değiştirdim, ardından dönen veriyi global değişkenimize aktardım. currencyPoller fonksiyonumuz ise bir özyinelemeli fonksiyon olup kod çalıştığından itibaren zaman sabitimiz kadar aralıklarla veri değişkenimizi yenileyecektir.

Şimdi “node index.js” yazarak çalıştıralım ve terminalde “I’m alive” yazısını gördüğümüzden emin olalım. Yazıyı gördükten sonra browserimizden localhost:3000 adresine gidip istek alabiliyor muyuz görelim. Eğer iki işlemimiz de başarılı ise artık başlayabiliriz.

Canlı Zamanlı Döviz Kuru Kontrolü Yapımı

Node.js taraflı veri gönderimi

Yukarıda gördüğünüz kısımda Node.js projemizin temelini oluşturmuştuk. Şimdi sokete yayın yapmamız için gereken kısma başlayabiliriz.

io.on("connection", (socket) => {
    console.log(`Yeni bir bağlantı yapıldı.`)
    let socketPoller = () => {
        socket.emit('currency-data', Data)
        setTimeout(() => {
            socket.emit('currency-data', Data)
            console.log(`Bağlantıya veri gönderimi yapıldı.`)
            socketPoller()
        }, ZAMAN);
    }

    socketPoller()

    socket.on("disconnect", () => {
        console.log(`Bağlantı koptu.`)
    })
})

Bu kod bloğunu konuşarak başlayalım. Gözümüze çarpması gereken kritik kısımlar io.on fonksiyonu, socket.emit fonksiyonlarıdır. io.on fonksiyonu bağlantı geldiğinde yapılacak eylemler dizisini tetikler. Buranın içerisine yazacağımız kodlar sadece ve sadece bağlantı geldiyse çalışacaktır.

socket.emit fonksiyonu ise ilk argüman olarak bir emit ismi almaktadır. Bu ismi siz belirleyip karşı clientte de bu isme göre dinleme yapacaksınız. İkinci argüman ise göndermek istediğiniz veri olmalıdır. Kodda biraz önce veri çekerken yaptığımız sürekli gönderim işlemini implemente ettik.

Bu kod bloğumuzu currencyPoller() satırının hemen ardına ekleyebiliriz. Şimdi clientte dinleme işlemine geçelim.

Client taraflı dinleme işlemi

Client tarafında dinlemek için öncelikle veriler.html diye bir dosya oluşturunuz. Ardından soket kodumuzun alt kısmına şu satırları ekleyiniz.

app.get('/', (req, res) => {
    res.sendFile(__dirname + '/veriler.html');
});

Bu kod localhost:3000 adresine eriştiğimizde veriler.html dosyasının render edilmesini sağlayacaktır. Ardından veriler.html dosyasının içeriğini aşağıdaki gibi düzenleyiniz.

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Canlı zamanlı USD kuru</title>
</head>

<body>
    <div id="currency">
    </div>

    <script src="/socket.io/socket.io.js"></script>
    <script src="https://code.jquery.com/jquery-3.4.1.min.js"></script>
    <script>
        $(function () {
            var socket = io();
            socket.on('currency-data', function (data) {
                $("#currency").html(
                    `Dolar kuru: ${data.ForexSelling}<br>Yenilendiği tarih: ${new Date().getHours()}:${new Date().getMinutes()}:${new Date().getSeconds()}`
                )
            });
        });
    </script>
</body>
</html>

Burada gözümüze çarpması gereken kısım script taglarımızın içerisidir. var socket = io() komutu ile soket bağlantımızı açtık. Ardından clientte currency-data verimizi socket.on komutunu kullanarak dinlemeye başladık. Dinlediğimiz veriyi basit bir şekilde jQuery kullanarak ekrana yazdırdım ve güncellendiği belli olsun diye saati ekledim.

Bu işlemler bittikten sonra node index.js yazınız ve browserinizden localhost:3000 adresini takip ediniz.

Projenin bitmiş halini şu adresten ziyaret edebilirsiniz: https://github.com/dogukanoksuz/realtime-currency

Eğer canlı halini videolu görmek istiyorsanız:

Anlatımımı takip ettiğiniz için teşekkür ederim. Eğer socket.io’da ilerlemek istiyorsanız iyi bir başlangıç yaptınız ancak buradaki bilgilerle sınırlı kalmayın! Emit cheatsheet’e göz atın, ayrıca Türkçe çevirisi de sitemde mevcut! Buraya tıklayarak gidebilirsiniz. namespace konusuna bakın, roomlara bakın, clientten de servera nasıl mesaj gönderebildiğinizi deneyin. Daha fazla detay öğrenmek için https://socket.io/docs/ adresini ziyaret edebilirsiniz. Yazdığınız soket uygulamalarını test etmek için ise https://socketserve.io adresini ziyaret edebilirsiniz. Sorularınızı yorum bölümünde yanıtlıyor olacağım.

Selamlar, uzun zamandır buraya yazı girmemişim. Bir süredir üzerinde çalıştığım PHP Spotify API'ın nasıl kullanıldığına dair bir Türkçe doküman tarzı bir şey hazırlamak istedim. Önden belirteyim, sorularınızı da yorum bölümünde yanıtlayacağım. Bu sayede hem ben hem de siz öğreneceksiniz. Temel olarak konuştuğumuza göre konuşmaya başlayalım.

PHP Spotify API için gereksinimler:

• PHP 7.4
• Composer
• Spotify üyeliği
• biraz da programlama tutkusu :)

Spotify Developer panelinde uygulama oluşturma:

API'ımızı kullanabilmemiz için Spotify developer panelinde uygulama oluşturmamız gerekiyor. Gelin beraber yapalım.

• https://developer.spotify.com adresine girin ve hesabınızla giriş yapın.
  
  
• Giriş yaptıktan sonra https://developer.spotify.com/dashboard/applications altına ilerleyelim ve yeşil "Create an app" düğmesine tıklayalım.
  
  
• 
  İlk boşluğa uygulama adınızı, ikinci boşluğa da açıklamanızı yazınız ardından tiklerin içeriğini okuyarak işaretleyin ve Create diyin :)
  
  
• 
  Bu iki keyi güvenli bir yere not alın, ileride API bağlantımızı yaparken ihtiyacımız olacak.
  
  

PHP Spotify API nasıl kullanılır?

• Öncelikle temel projemizi açacağız. Bir klasör oluşturun, index.php dosyasını oluşturun.
• Ardından terminal/cmd ekranını açın, klasöre girdikten sonra composer require jwilsson/spotify-web-api-php yazın.
• index.php dosyasının başına

Access token alıp sisteme bağlanmak:

$session = new SpotifyWebAPI\Session('CLIENT_ID', 'CLIENT_SECRET', 'REDIRECT_URI');
$api = new SpotifyWebAPI\SpotifyWebAPI(['auto_refresh' => true, 'auto_retry' => true]);
if (isset($_GET['code'])) {
    $session->requestAccessToken($_GET['code']);
    $api->setAccessToken($session->getAccessToken());
    // $refresh_token = $session->getRefreshToken();
    print_r($api->me());
} else {
    $options = [
        'scope' => [
            // bu kısım hakkında detaylı bilgi için:
            // https://developer.spotify.com/documentation/general/guides/scopes/
            'user-read-email',
        ],
    ];

    header('Location: ' . $session->getAuthorizeUrl($options));
    die();
}

Yukarıdaki kod bloğunu açıklarsak CLIENT_ID kısmına aldığımız id, aynı şekilde secret kısmına da diğer aldığımız kodu gireceğiz. Redirect_uri kısmı ise bu auth işlemini nerede gerçekleştirdiğinize bağlıdır. Ben şahsen bunu ayrı bir sayfada yapıp ardından access tokeni veritabanımda depolamayı tercih ediyorum. Bu kod bloğunu girdiğiniz sayfanın URL'sini yazmanız şimdilik yeterlidir.

Refresh token kullanarak Access token yenilemek:

$session = new SpotifyWebAPI\Session('CLIENT_ID', 'CLIENT_SECRET', 'REDIRECT_URI');
$session->refreshAccessToken(Auth::user()->spotify_refresh_token);
/* bu iki değişkeni bir databasede saklamak cidden iyi fikir. */
$newAccessToken = $session->getAccessToken(); 
$newRefreshToken = $session->getRefreshToken();

Bu iki auth işlemini öğrendikten sonra artık oyuna başlayabiliriz. Aşağıdaki iki kodla API nesnemizi oluşturalım:

$api = new SpotifyWebAPI\SpotifyWebAPI(['auto_refresh' => true, 'auto_retry' => true]);
$api->setAccessToken($session->getAccessToken());

Ardından bu oluşturduğumuz $api değişkeni üzerinden işlemleri yapmaya başlayalım.

addMyTracks - Sevilen Şarkılara Ekleme Yapmak

$api->addMyTracks($tracks)

Access tokeni kullanılan kullanıcının kütüphanesine parça ekler.
https://developer.spotify.com/documentation/web-api/reference/library/save-tracks-user/

Argümanlar

• $tracks string|array - Eklenecek parçaların ID(leri) veya Spotify URI(ları)

Ne döndürüyor?

• boolean Parça kütüphaneye eklendi mi eklenmedi mi?

getMyDevices - Kullanıcının Cihazlarını Almak

$api->getMyDevices()

Kullanıcının cihazları hakkında bilgileri almak.
https://developer.spotify.com/documentation/web-api/reference/player/get-a-users-available-devices/

Ne dönüyor?

• array|object Kullanıcının cihazları. Dönen veri tipini return_assoc ile değiştirebilirsiniz.

changeMyDevice - Çalan Cihazı Değiştirmek

$api->changeMyDevice($options)

Kullanıcının müzik çaldığı cihazı değiştirir.
https://developer.spotify.com/documentation/web-api/reference/player/transfer-a-users-playback/

Argümanlar

• $options array|object - Gereken ayarların listesi.
  • string|array device_ids Zorunludur. Değiştirmek istediğiniz cihazın ID değerini girmelisiniz.
  • bool play Opsiyonel olarak diğer cihazda oynatmanın başlama durumunu belirlersiniz.

Ne döndürüyor?

• boolean İşlem başarılı mı?

changeVolume - Sesi Değiştirmek

$api->changeVolume($options)

Kullanıcının ses düzeyini değiştirir.
https://developer.spotify.com/documentation/web-api/reference/player/set-volume-for-users-playback/

Argümanlar

• $options array|object - Ses ayarları
  • int volume_percent Zorunlu, ayarlanacak sesin düzeyi.
  • string device_id Opsiyonel, sesi değiştirilecek cihazın ID'si.

Ne dönüyor?

• boolean İşlem başarılı mı?

createPlaylist - Playlist Oluşturmak

$api->createPlaylist($options)

Yeni bir çalma listesi oluşturun.
https://developer.spotify.com/documentation/web-api/reference/playlists/create-playlist/

Argümanlar

• $options array|object - Playlist için ayarlar listesi.
  • string name Zorunlu, çalma listesinin ismi.
  • bool public Opsiyonel, çalma listesi herkese açık mı?

Ne dönüyor?

• array|object Yeni çalma listesinin kendisi, tipini return_assoc ile değiştirebilirsiniz.

me - Kullanıcının Bilgilerini Getirmek

$api->me()

O anda giriş yapmış olan kullanıcının bilgilerini alabilirsiniz.
https://developer.spotify.com/documentation/web-api/reference/users-profile/get-current-users-profile/

Ne dönüyor?

• array|object O an giriş yapmış olan kullanıcının bilgileri döner. Tipini return_assoc ile değiştirebilirsiniz.

play - Çalmayı Başlatmak

$api->play($deviceId, $options)

Çalma işlemini başlatır.
https://developer.spotify.com/documentation/web-api/reference/player/start-a-users-playback/

Argümanlar

• $deviceId string - Opsiyonel, çalmak istediğiniz cihazın ID'si.
• $options array|object - Opsiyonel, ayarlar.
  • string context_uri Opsiyonel, çalınacak şeyin Spotify URI'ı (farkı parça değil albüm, podcast çalabiliyor)
  • array uris Opsiyonel, çalınacak parçaların Spotify URI'ı.
  • object offset Opsiyonel, çalma işleminin hangi kısımdan başlaması gerektiği.

Ne dönüyor?

• boolean İşlem başarılı mı?

queue - Çalma Sırasına Şarkı Eklemek

$api->queue($trackUri, $deviceId)

Çalma sırasına şarkı ekler.
https://developer.spotify.com/documentation/web-api/reference/player/add-to-queue/

Argümanlar

• $trackUri string - Zorunlu, çalacak parçanın Spotify URI'ı.
• $deviceId string - Opsiyonel, cihaz ID'si.

Ne dönüyor?

• boolean İşlem başarılı mı?

search - Arama Yapmak

$api->search($query, $type, $options)

Spotify kütüphanesinde arama yapmak için kullanıyoruz.
https://developer.spotify.com/documentation/web-api/reference/search/search/

Argümanlar

• $query string - Aranacak terim.
• $type string|array - Aranacak terimin türü. album, artist, playlist, track, show, episode kelimelerinden birini veya birden fazlasını seçebilirsiniz.
• $options array|object - Arama ayarları
  • string market Opsiyonel, hangi pazarlarda aransın. Ülke kodu ile seçilir.
  • int limit Opsiyonel, kaç sorgu dönsün?
  • int offset Opsiyonel, kaç item geçilsin?

Ne dönüyor?

• array|object Arama sonuçları, tipini return_assoc ile değiştirebilirsiniz.

next - Sıradaki Parçayı Çal

$api->next($deviceId)

Kullanıcının kuyruğundaki sıradaki parçayı çalar.
https://developer.spotify.com/documentation/web-api/reference/player/skip-users-playback-to-next-track/

Argümanlar

• $deviceId string - Opsiyonel, çalacak cihaz ID'si

Ne dönüyor?

• boolean İşlem başarılı mı?

pause - Şarkıyı Durdurmak

$api->pause($deviceId)

Çalma işlemini durdurur.
https://developer.spotify.com/documentation/web-api/reference/player/pause-a-users-playback/

Argümanlar

• $deviceId string - Opsiyonel, çalacak cihaz ID'si

Ne dönüyor?

• boolean İşlem başarılı mı?

getTrack - Şarkının Bilgilerini Çekmek

$api->getTrack($trackId)

ID'sine sahip olduğunuz şarkının bilgilerini almak.
https://developer.spotify.com/documentation/web-api/reference/tracks/get-track/

Argümanlar

• $trackId string - ID veya Spotify URI girebilirsiniz, zorunludur.

Ne dönüyor?

• array|object Şarkı bilgileri, türü return_assoc ile değiştirebilirsiniz.

getMyCurrentPlaybackInfo - Çalan Şarkıyı Hakkında Bilgi Almak

$api->getMyCurrentPlaybackInfo()

Kullanıcının o andaki oynatma bilgilerini almak.
https://developer.spotify.com/documentation/web-api/reference/player/get-information-about-the-users-current-playback/

Ne dönüyor?

• array|object Kullanıcının oynatma bilgisi, dönen veri tipini return_assoc ile değiştirebilirsiniz.

getMyPlaylists - Kullanıcının Çalma Listelerini Almak

$api->getMyPlaylists($options)

Kullanıcının çalma listelerini getirir.
https://developer.spotify.com/documentation/web-api/reference/playlists/get-a-list-of-current-users-playlists/

Argümanlar

• $options array|object - Opsiyonel, ayarlar.
  • int limit Opsiyonel, kaç tane getirilsin?
  • int offset Opsiyonel, kaç tanesi geçilsin?

Ne dönüyor?

• array|object Kullanıcının playlistleri, dönen veri tipini return_assoc ile değiştirebilirsiniz.

getMySavedTracks - Kullanıcının Beğendiği Şarkılar

$api->getMySavedTracks($options)

Kullanıcının beğendiği şarkıların listesi.
https://developer.spotify.com/documentation/web-api/reference/library/get-users-saved-tracks/

Argümanlar

• $options array|object - Opsiyonel, ayarlar.
  • int limit Opsiyonel, kaç tane getirilsin?
  • int offset Opsiyonel, kaç tanesi geçilsin?

Ne dönüyor?

• array|object Kullanıcının beğendiği şarkılar, dönen veri tipini return_assoc ile değiştirebilirsiniz.

getPlaylist - Playlist Hakkında Bilgi Getirmek

$api->getPlaylist($playlistId)

IDsi belirli olan 
https://developer.spotify.com/documentation/web-api/reference/playlists/get-playlist/

Argümanlar

• $playlistId string - Playlistin Spotify URI'ı.

Ne dönüyor?

• array|object Playlist hakkında bilgiler, dönen veri tipini return_assoc ile değiştirebilirsiniz.

getPlaylistTracks - Playlistten Şarkıları Çekmek

$api->getPlaylistTracks($playlistId, $options)

Playlistten şarkıları getirir.
https://developer.spotify.com/documentation/web-api/reference/playlists/get-playlists-tracks/

Argümanlar

• $playlistId string - Playlistin Spotify URI'ı.
• $options array|object - Opsiyonel, ayarlar.
  • int limit Opsiyonel, kaç tane getirilsin?
  • int offset Opsiyonel, kaç tanesi geçilsin?

Ne dönüyor?

• array|object Playlist hakkında bilgiler, dönen veri tipini return_assoc ile değiştirebilirsiniz.

Önemli olan tüm fonksiyonları çevirdiğimi düşünüyorum. Eksik kaldığını düşündüğünüz kısımlar varsa yorum kısmında belirtirseniz sevinirim. Anlamadığınız kısımlarda da sorularınıza yanıt vermeye çalışacağım. Okuduğunuz için teşekkür ederim. Umarım faydalı olmuştur.

Faydalı kaynaklar:
https://github.com/jwilsson/spotify-web-api-php/tree/master/docs/method-reference
https://github.com/jwilsson/spotify-web-api-php/tree/master/docs/examples

Yazdığınız API'ların bazı zamanlar güvensiz olduğunu, bu sistemde kullanıcı girişi olsa, ama nasıl yaparım diye düşündüğünüz olmuştur. Normal şartlarda bu işi JWT token sistemi implemente ederek yapabiliyoruz ancak bu sistemi sıfırdan oluşturmak uzun zaman alıyor. Laravel hemen burada da imdadımıza yetişiyor :)

JWT Nedir?

JWT'nin açılımı JSON Web Token'dir. Bu tokeni kullanarak API sistemlerinizi kullanıcı bazlı ayrıştırabilir, güvenlik önlemi olarak token sahibi olmayan kullanıcıların girişine izin vermeyebilirsiniz. Çalışma mantığından bahsedecek olursak aşağıdaki resim üzerinden ilerleyelim.

İlk önce sisteme login olmak için post atarsınız. Gönderdiğiniz veriler doğruysa server size tokeninizi döndürür. Ardından aldığınız tokeni diğer attığınız sorgularda Authorization (doğrulama) headerine koyar ve sorgu atarsanız client her seferinde tokeninizi kontrol eder ve doğruysa size yanıtı gönderir. Sistem basitçe bu şekilde işlemektedir ancak her clientin public ve secret keyleri vardır. JWT tokenlarının güvenliği buna göre sağlanmaktadır. Bu sayede dışarıdan tokenlarınızı üretip sisteminize sorgu atamazlar.

Laravel Passport nasıl kurulur?

Laravel projenizin hali hazırda oluşturulduğunu varsayarak anlatmaya devam edeceğim. 

• İlk önce Passport paketini kuralım:
  composer require laravel/passport
  
  
• Ardından .env dosyanızı düzenleyip php artisan migrate komutunu çalıştırın.
  
  
• php artisan passport:install komutunu girelim ve keylerimiz oluşturulsun. Bu keyleri bir yere not alınız ihtiyacınız olacak.
  
  
• Ardından giriş yapmak için kullandığınız modelinizin (standart olarak app/User.php) içerisine use Laravel\Passport\HasApiTokens; satırını ekleyiniz.
  
  
  
  
• app/Providers/AuthServiceProvider.php içindeki boot metoduna \Laravel\Passport\Passport::routes(); satırını ekleyiniz.
  
  
  
  
• config/auth.php dosyasında guards arrayi içerisindeki api => driver kısmını bulun ve driveri passport olarak değiştirin.
  
  
  
  
• Sistem kurulumumuz başarıyla tamamlanmıştır.
  
  

Laravel Passport Nasıl Kullanılır?

• Sisteminizde bir kullanıcı açın. Eğer nasıl yapacağınızı bilmiyorsanız php artisan tinker komutu ile oluşturabilirsiniz.
  App\User::create(['name' => 'Divergent', 'email' => 'me@dogukan.dev', 'password' => bcrypt('divergent')]);
  
  
• Ardından aşağıdaki şekilde request bodynize form-datayı ekleyiniz.
  
  
  
  Client id size verilen grant keyin idsidir.
  Client secret size verilen grant keyin kendisidir.
  Grant type nasıl giriş yapmak istediğinizi seçtiğiniz alandır.
  Username ve password da token almak istediğiniz kullanıcının giriş bilgileridir.
  
  
• Bu şekilde istek attıktan sonra size dönecek olan tokeni Postman ile aşağıdaki şekilde kullanabilirsiniz. Dönen tokenin türü Bearer Token olacaktır.
  
  
  
  
  

Okuduğunuz için teşekkür ederim. Sorularınızı yorum bölümünde belirtirseniz dönüş yapıyorum. İyi çalışmalar.

Bu makalede Windows'a Windows Subsystem for Linux 2'yi nasıl kuracağımızı öğreneceğiz. Öncelikle bahsetmemiz gereken konu tabiki de WSL2 nedir?

WSL Nedir?

WSL'in açılımı Windows Subsystem for Linux'tur. Basit olarak konuşursak sanal makine olmadan Linux terminalini Windows üzerinde kullanmanızı sağlamaktadır. Git Bash gibi bir kaç UNIX komutu eklenmiş toollara göre farklılık göstermektedir. WSL üzerinde direkt olarak Linux uygulamalarını çalıştırabilirsiniz. WSL Linux kernelini Windows üzerinde çalıştırmak gibi bir şey. Kulağa iyi geliyor değil mi?

Eğer tecrübeli bir geliştiriciyseniz Linux'un sunucu bazlı işlemleri geliştirmek ve açık kaynaklı teknolojileri kullanmak istediğinizde en iyi çözüm olduğunu bilirsiniz. Bu işlemlerin hepsini tabiki Windows üzerinde de yapabilirsiniz ancak kullanıcı deneyiminiz Linux üzerindeki kadar iyi olmayacaktır. Bulut hosting firmalarının bir çoğu müşterilerine stabilite için Linux kullanımını önermektedir. WSL kullanarak Linux gerektiren işlemlerinizi uyumluluk sorunları yaşamadan kolayca çözebilmektesiniz.

Arch Linux WSL Nasıl Kurulur?

Öncelikle Windows'un son sürümüne sahip olmalısınız, eğer değilseniz de güncellemeniz gerekiyor. Çalıştır penceresine winver yazarak sürüm numarasını öğrenebilirsiniz. Bu rehberi yazarken benim sürüm numaram 2004/19041. Rehberdeki adımları takip ettiğinizde eğer hata aldıysanız Windows sürümünüzü kontrol ediniz. Sürümün aynı olduğuna emin olduktan sonra Windows Subsystem for Linux'u etkinleştirmemiz gerekiyor.

Bu işlemi yapmak için Denetim Masası -> Programlar -> Programlar ve Özellikler penceresini takip ettiğinizde sol kısımda Windows özelliklerini aç düğmesine tıklıyoruz. Ardından aşağı kaydırıp Windows Subsystem for Linux seçeneğini işaretleyin ve OK basın. Bilgisayarınızı yeniden başlatacak ve kurulumu gerçekleştirecektir.

Sisteminizde WSL'in çalışması için BIOS ayarlarınızdan UEFI'nin açık olması gerekmektedir. Ayrıca sanallaştırma ayarının da açık durumda bulunması zorunludur.

İkinci aşamamızda Windows için Sanal Makine Platformunu aktifleştirmemiz gerekiyor. Bu işlemi yapabilmek için öncelikle yönetici olarak bir PowerShell penceresi çalıştırın. 

Enable-WindowsOptionalFeature -Online -FeatureName VirtualMachinePlatform komutunu çalıştırın ve bilgisayarınızı yeniden başlatın.

Üçüncü aşamada Arch Linux WSL dağıtımını indiriniz. Github indirme sayfası https://github.com/yuk7/ArchWSL bu adrestedir. Buradan zip dosyasını indirip kurulumu yapmak istediğiniz yere çıkartınız. Ardından Arch.exe dosyasını çalıştırarak kurulumu gerçekleştirebilirsiniz. Eğer Arch değil de farklı bir dağıtım kurmak istiyorsanız bu aşamada Microsoft Store'a giriş yaparak Ubuntu, Kali gibi çeşitli dağıtımları indirebilirsiniz.

Bu aşamadan sonra aslında WSL kurulumunu tamamlamış olacağız ancak Docker desteğini getiren WSL2'ye yükseltme işlemini yapmamız gerekmekte. Yoksa tam verimli bir Linux performansı alamamaktayız.

WSL2 yükseltmesini yapabilmek için https://wslstorestorage.blob.core.windows.net/wslblob/wsl_update_x64.msi adresinden WSL2 kernel güncellemesini indirip bilgisayarınıza kurun. Kurulum gerçekleştikten sonra PowerShelli yönetici olarak çalıştırın ve wsl --set-default-version 2 komutunu girin. Ardından Arch veya hangi distroyu kullanıyorsak yükseltmek için wsl --set-version Arch 2 yazınız. Arch yerine distro adı gelecek ancak eğer isimden emin değilseniz wsl -l -v komutunu kullanarak yüklü WSL distrolarını görebilirsiniz.

Son aşamamızda kurulumun başarılı olduğunu görmek için wsl -l -v komutunu girin. Aşağıdaki gibi çıktı alıyorsanız işlemimiz başarıyla tamamlanmış demektir.

WSL nasıl kullanılır?

WSL'i kullanabilmek için Microsoft Store üzerinden Windows Terminal kurulumu yapmalısınız. Ardından kapak fotoğrafında olduğu gibi kurulumunu yaptığınız distroyu başarılı şekilde kullanabileceksiniz.

Makalemi okuduğunuz için teşekkür ederim, takıldığınız yerleri yorum bölümünde sormaktan çekinmeyiniz.

Bugün node.js ve Express kullanarak RESTful API’ları nasıl geliştirebileceğimizi temel olarak öğrenmeye çalışacağız.

Bilinmesi gereken kavramlar

İlk önce API kavramı nedir bunu ele almamız gerekir. API kavramının ingilizce olarak açılımına bakarsak Application Programming Interface olarak geçer, yani Uygulama Programlama Arayüzü olarak çevirebiliriz.

API’ları genelde program geliştiricileri birden fazla servisi bir arada kullanmak istediğinde kullanmaktadır. Günümüzdeki çoğu sistem API kullanarak çalışmaktadır. Bizim bugün API geliştirme sebebimiz ise next.js ile geliştireceğimiz basit uygulamanın backend servisini yazmak olacak. API testimiz için Postman uygulamasını kullanacağız. Altta linki mevcuttur.

Kılavuza devam etmeden önce JavaScript geliştirebildiğinize emin olun ve ES6 yeniliklerinden let, const ve arrow functions gibi yenilikleri öğrenin.

MongoDB üzerinde temel olarak bir bilginiz olması iyi olacaktır. Node.js üzerinde mongoose frameworkünü kullanarak ilerleyeceğiz.

Diğer bilmediğimiz kavram ise Express’in ne olduğu olabilir diye düşündüğümden onu da açıklayalım. Express, node.js üzerinde en yaygın olarak kullanılan web geliştirme frameworküdür. Minimal ve hızlı olması, temiz kod prensiplerini benimsemesi Express’i tercih edilebilir bir seçenek haline getirmektedir. Bizim için routing ve middleware işlemlerini çözmesi de güzel taraflarındandır. Bu sebepten Express ile ilerleyeceğiz.

Bu konular hakkında detaylı bilgi edinebileceğiniz kaynakları aşağıya bırakıyorum.

Araştırma yapabileceğiniz kaynaklar ve linkler

• https://expressjs.com

• https://nodejs.org/en/docs/

• https://mongoosejs.com/docs/guide.html

• https://www.postman.com/

• https://github.com/dogukanoksuz/express-mongo-crud-app

node.js ve Express kurulumu, sisteminizde bulunması gerekenler

İlk önce projemizi başlatabilmek için sisteminizde node.js ve npm/yarn paket yöneticilerinden birinin kurulu olması gerekmektedir. Ben npm tercih ettiğimden kılavuzdaki komutları npm olarak kullanacağım. Sisteminize nasıl kurulacağını Google üzerinden araştırabilirsiniz. (örnek arama cümleciği: windows nodejs kurulumu). Bu eksiği kapattıktan sonra veritabanı yönetim sistemimiz olarak ben MongoDB kullanmak istiyorum. Siz tercihinize göre diğer veritabanları için ORM’leri kullanabilirsiniz. (MySQL, MariaDB için Sequelize kullanılabilir.). Sisteminize MongoDB kurulumu gerçekleştirirseniz kolayca kılavuzu takip edebilirsiniz. Linux üzerinde MongoDB için devilbox kullanıyorum. Devilbox kurulumu ve kullanımını buraya tıklayarak takip edebilirsiniz.

RESTful API projesine başlangıç

Komutları Linux üzerinden anlatacağımı belirteyim ancak çok komplike olmadığından Windows ve macOS ile de eşleştirmeleri kolayca yapabilirsiniz.

Bugün temel olarak CRUD işlemlerini anlayabilmemiz için tek modelli bir uygulama geliştireceğiz. Ben basit olarak notları tuttuğumuz bir uygulama seçmek istedim. Siz isterseniz sadece yazılar modeline sahip bir uygulama geliştirip şemayı genişletebilirsiniz.

1. Terminalinizi açın, uygulamanız için bir klasör oluşturun.

$ mkdir node-express-app

2. Klasörünüzde package.json dosyasını oluşturun.

$ cd node-express-app

$ npm init

komutunu girdikten sonra önemli olan tek kısım şu anlık entry point kısmı, diğerlerine enter basıp geçebilirsiniz. Entry point seçeneğine server.js yazınız.

3. Express ve diğer paketlerin kurulumunu yapın.

$ npm install express body-parser mongoose –save

4. Kurulum işlemi tamamlandıysa klasörünüzde node_modules klasörü ve package.json dosyalarının oluşması gerekmektedir. Kontrol edin eğer problem yok gibi gözüküyorsa devam edebiliriz.

Express web sunucusunun kurulumu

Node.js geliştirebilmek için gereken temel adımları halledip paketlerimizi kurduğumuza göre klasörümüzü favori kod editörümüzde açarak devam edelim. Açtıktan sonra klasör içerisine server.js adında bir dosya oluşturun ve içeriğini şu şekilde tanımlayın:

Öncelikle express ve body-parser paket içeriye aktardık. Express’in ne olduğundan zaten bahsettik. Body-parser ise çeşitli içerik tiplerini Express üzerinde parse edip kullanmamızı sağlayan bir paket.

Ardından express uygulamamızı oluşturduk. İki tane body-parser middlewareını app.use() metodunu kullanarak express uygulamamıza tanımladık. Bu tanımladığımız middlewarein request ve response objelerine erişimi var, bu objeler üzerinde çeşitli işlemler gerçekleştirerek bizim kolayca işlemleri gerçekleştirmemizi sağlayacak.

Sonrasında bir adet GET rotası içeren hoşgeldin mesajlı basic bir rota oluşturduk.

En sonunda da 3000 portundan gelen istekleri dinleyeceğimiz web sunucumuzu başlattık.

Veritabanı erişimini konfigüre etmek ve bağlanmak

Öncelikle config adında bir klasör oluşturalım, veritabanı bağlantı cümlemizi bu klasöre ekleyeceğiz. Ardından bu klasörün içinde db.config.js adında bir dosya oluşturun, içeriği şu şekilde olsun:

module.exports = {

    url: 'mongodb://172.16.238.16:27017/backend-app'

}

Buradaki bağlantı cümlesi sizin sunucu konfigürasyonunuza göre değişebilir ancak devilbox üzerinde bağlantıyı bu şekilde sağlamaktayız.

Ardından aşağıdaki kod bloğunu server.js içerisinde app.use(bodyParser.json()) altına ekleyin.

Bu işlemin ardından node server.js komutunu çalıştırarak terminalden veritabanına bağlanabiliyor musunuz kontrol edin. Görmeniz gereken mesaj “Veritabanına bağlantı başarılı” tarzı olmalıdır.

Mongoose kullanarak model tanımlamak

Veritabanı bağlantı, basit server işlemleri gibi şeyleri hallettiğimize göre ilk modelimizi tanımlayabiliriz.

$ mkdir -p app/models

$ cd app/models

komutlarını giriyoruz ve bu klasör içerisinde note.model.js adında şu içeriğe sahip bir dosya oluşturuyoruz.

Gördüğünüz üzere not modelimiz gayet basit. Sadece başlık ve içerik olaraktan iki alan içermekte. Timestamps ise otomatik olarak iki alan ekliyor ve güncelleme/oluşturulma tarihlerini tutuyor.

Express kullanarak rotaları tanımlamak

Sırada rotalarımızı tanımlama işlemimiz var. app/routes klasörünü oluşturalım.

$ mkdir app/routes

$ cd app/routes

Şimdi note.routes.js adında bir dosya oluşturun ve içeriği şu olsun:

Ardından app.listen() satırından önce şu kısmı ekleyin:

require(‘./app/routes/note.routes’)(app)

Sunucuyu çalıştırmaya çalışırsanız başlamayacaktır çünkü rotalarımız için controllerimizi henüz tamamlamadık.

Kontrolcü fonksiyonlarını oluşturmak

app/controllers klasörünü oluşturun ve içerisine aşağıdaki içerikle note.controller.js dosyasını oluşturun.

Projemizde kullanılan Mongoose komutları için API dokümantasyonunu inceleyebilirsiniz.

• Mongoose save()

• Mongoose find()

• Mongoose findById()

• Mongoose findByIdAndUpdate()

• Mongoose findByIdAndRemove()

Postman ile API test etmek

Veritabanına eklenmiş tüm notları almak. (GET /notes)

Sadece bir not getirmek (GET /notes/:noteId)

Yeni bir not oluşturmak (POST /notes)

Not silmek (DELETE /notes/:noteId)

Sonuç

Bu yazımda temel olarak MongoDB, Express, Node stacki ile basit bir CRUD uygulaması nasıl geliştirebilirsiniz onu göstermeye çalıştım. Umarım faydalı olabilmişimdir. Sorularınızı yorum bölümünde belirtirseniz elimden geldiğince yardımcı olmaya çalışırım. Buraya kadar takip edenlere ayrıca teşekkür ediyorum :)

Projenin final hali: https://github.com/dogukanoksuz/express-mongo-crud-app

Eğer takıldığınız kısımlar olursa veya soru sormak isterseniz yorum bölümünü kontrol ediyorum. Yorumlarınızı ve eleştirilerinizi bekliyorum.

İnsanlık için faydalı bir şeyler yapabiliyorsam ne mutlu bana.

Merhaba dostlar, elimden geldiğinde uzun araştırmalar sonucunda bulduğum fixleri yayınlamaya çalışıyorum. Bugün de Deepin kurduktan sonra Wi-Fi bağlantı problemi yaşadım. Bunu çözmek için github üzerinde gezinirken bir fix buldum. Araştırması kolay olmadığımdan burada da yayınlamaya karar verdim.

Problem:

Wi-Fi bağlantısına tıklanıp şifre yazılıyor ancak bağlantı sağlanamıyor. Wi-Fi sürekli kopmuş ve yeniden bağlanmaya çalışıyormuş gibi oluyor.

Bağlantı Probleminin Çözümü:

• su yazarak root olun.
• systemctl disable dhcpcd komutunu girin. NetworkManager ile çakıştığından problem yaratabilir.
• nano /etc/NetworkManager/NetworkManager.conf komutunu girerek belirtilen dosyayı açın.
• Şu satırları ekleyin:
  [device]
wifi.scan-rand-mac-address=no
• reboot yazarak sistemi yeniden başlatın.
• Tekrar giriş yaptığınızda başarılı şekilde Wi-Fi bağlantısı yapabiliyor olmalısınız.

Bugün wordpress temanıza nasıl admin paneli (yönetim paneli) ekleyebileceğinizi anlatacağım. Kendi yazdığınız temaya kullanımı kolay olsun diye veya satılabilsin diye admin paneli eklemek isteyebilirsiniz. Bunu yapmanın çok kolay bir yolu var. Tek ihtiyacınız olan PHP syntaxını bilmek ve biraz ingilizce okuyabilmek.

Makalemizde Codestar Framework'tan bahsedeceğiz. Öncelikle https://codestarframework.com/ adresini ziyaret ediyoruz ve gerekli dosyaları "Download Free Version" düğmesine basarak indiriyoruz. İndirdiğimiz dosyaları bir yere çıkartıyoruz. Ardından temamıza nasıl kuracağımıza geçelim.

Codestar Framework admin paneli nasıl kurulur?

• Çıkardığımız dosyaları temanın istediğimiz bir dizinine koyabiliriz. Ben '/inc' adında bir klasör açıp onun altına atmayı tercih ediyorum.
• Ardından functions.php dosyamızı açıyoruz. İçerisine require get_template_directory() . '/inc/framework/codestar-framework.php'; şeklinde frameworkümüzün bootstrapper dosyasını ekliyoruz. Dosya yolu sizin seçtiğiniz isme göre değişiklik gösterebilir. Ezbere bakmayınız.
• Admin panelimizin kurulumunu başarıyla tamamladık :)

Codestar Framework admin paneli nasıl kullanılır?

Kurulumu tamamladık ama admin panelini nasıl kullanacağız ne yapacağız dediğinizi duyar gibiyim. Yukarıdaki kod bloğunu incelersek bu bir admin panelini nasıl tanımladığımızı gösteriyor. Adım adım incelemeye başlayalım.

• Öncelikle bir php dosyası açın ve bunu functions.php içerisinde Codestar framework çağırdığımız yerin hemen altında çağırın. Çağırmak için require komutunu kullanabilirsiniz.
• if ( class_exists( 'CSF' ) ) satırı frameworkün doğru şekilde çağırıldığını kontrol ettiğimiz kısım. Framework import edilmediyse hata almamızı önlemek için kullandığımız bir satır.
• $prefix diye tanımladığımız kısım temanın kısa adını belirttiğimiz bölüm. Diğer bildiğiniz temalarla ortak olmaması ve bir kez belirledikten sonra değiştirmemeniz iyi olacaktır. Tema ayarları bu kısa isimle veritabanında saklanacaktır.
• CSF::createOptions fonksiyonu içerisinde admin panelinin genel özelliklerini tanımlıyoruz. Ben en gerekli özellikleri yukarıdaki kısımda belirttim. Örneğin framework_title keyi admin paneline girdiğimizde headerde gözükecek ismi belirtmektedir. Menu settings diye belirttiğim kısımda ise admin panelinin menüsünde nasıl gözükeceğini belirlemekteyiz. 
• CSF::createSection fonksiyonu ile admin paneli içerisine alt sayfalar açmaktayız. Ben bu örnekte tek bir alt sayfa oluşturarak onun üzerinden ilerlemeyi tercih ediyorum.
• Title kısmında section yani alt sayfanın başlığını belirtiyoruz.
• Fields keyinin value kısmındaki array altına alt arrayler oluşturarak elemanları ekleme işlemini yapıyoruz. Bir örnek vermemiz gerekirse tema rengi seçeneği diye belirttiğim kısımda radio button kullanarak seçenek almışım. Buradaki en önemli kısım id kısmıdır. Buraya verdiğiniz isimler kolay ve aklınızda kalıcı isimler olsun. Sonradan temanın içerisinde bunları kullanacaksınız. 
• Yukarıdaki kodda çeşitli biçimlerin kullanımına örnekler yazılmıştır. Diğer elementleri de incelemek isterseniz: https://codestarframework.com/documentation/#/fields adresini ziyaret ederek örnek kod kullanımları ile elementlerin hepsini görebilirsiniz.

Bu ayarları temanın içinde nasıl çağıracağım?

• Ayarları çağırmak istediğiniz yerde $options = get_option( 'Belirlediğiniz prefix' ); kodunu kullanarak $options üzerine ayarların çağırıldığı bir array eklersiniz. O arrayin içeriğini var_dump($options); aracılığı ile görüntüleyip kolayca erişim sağlayabilirsiniz.
• Örneğin yukarıda anlattığımız theme-color yani tema rengi seçeneğini çağırıp kullanalım.

• if ( 'dark' == $options['theme-color'] ) { 
     wp_enqueue_style( 'divergent-bootstrap', get_template_directory_uri() . '/dist/css/bootstrap-dark.min.css' );
     wp_enqueue_style( 'divergent-style', get_template_directory_uri() . '/dist/css/style-dark.css' );
  } elseif ( 'grey' == $options['theme-color'] ) {
     wp_enqueue_style( 'divergent-bootstrap', get_template_directory_uri() . '/dist/css/bootstrap-blue.min.css' );   
     wp_enqueue_style( 'divergent-style', get_template_directory_uri() . '/dist/css/style-blue.css' );
  }

• Yukarıda görebileceğiniz gibi $options değişkeninin ['theme-color'] keyine ulaşarak o seçeneği almışım ve kontrolünü yaparak farklı stil dosyalarının çağırılmasını sağlamışım. Bunun gibi daha nice örnek verebiliriz. Detaylı kullanım görmek istiyorsanız sitemde yayınladığım divergent 100% SEO Uyumlu Wordpress Blog Teması makalemdeki temanın dosyalarını inceleyerek fikir alabilirsiniz.

Örnek admin paneli görüntüsü

Makalemi okuyup zaman ayırdığınız için teşekkür ederim. Sorularınız için aşağıdaki yorum bölümünü kullanmaktan çekinmeyiniz, yardımcı olacağım. 

Merhaba dostlar,

Uzun zamandır yazı giremiyordum. Okulun güz dönemi bitince biraz gevşemek ve işlere ara vermek istedim açıkçası. Sonra da bir abimizin ricası ile websitemdeki temayı Wordpress'e entegre etmeye karar verdim. 

Zaten websitemde halihazırda kullandığım ve 100% SEO uyumlu olan kendi yazdığım temamı modern standartlara uygun olarak ve yeni özellikler ekleyerek entegrasyonunu tamamladım.

Temanın özellikleri

• 100% SEO uyumlu
• Microcode, Schema.org entegrasyonları yapılı
• Tema paneli var
• İki renk seçeneği var (siyah, beyaz)
• Modern görünüm
• Temiz kodlama standartlarına uygunluk
• HTML5 article/aside gibi tagların doğru şekilde kullanımı
• Codestar framework ve _s boilerplate kullanıldı
• Thumbnail boyutları her zaman otomatik ve düzgün şekilde ayarlanıyor
• Menüler Wordpress paneli üzerinden ayarlanabiliyor
• Eklentilerden bağımsız, hiç eklenti ihtiyacınız yok

Temanın diğer renk şeması

Bu renk şemasını temayı entegre etmemi isteyen abimin isteği üzerine yaptım. Siyah ve kırmızı tonları yerine beyaz, mavi ve gri tonlarını kullanarak daha güven vaat eden bir renk şeması seçtik. Tema paneli üzerinden zevkinize göre iki seçeneği de kolayca tercih edebiliyorsunuz.

Temanın yönetim paneli

Temada problem var ne yapacağım?

Github üzerinden temanın issuelarını sürekli kontrol edip yeni bugfixler yapacağım, bunları da release olarak tekrardan github'da yayınlayacağım. Changelogları bu sayfa üzerinden tekrar paylaşırım, indirme sayfasında her zaman en yeni sürümü göreceksiniz.

Temanın kodlarını kullanabilir miyim?

Bu temayı tamamen ücretsiz olarak dağıtıyorum ve kodlarını istediğiniz yerde istediğiniz şekilde kullanabilirsiniz.

Temanın indirme linki

divergent Wordpress Temasını buraya tıklayarak indirebilirsiniz:
https://github.com/dogukanoksuz/divergent-wordpress-theme/releases

*footer linkini kaldırmazsanız çok sevinirim :)

Instagram API üzerine yaptığım paylaşımların rağbet görmesi sebebi ile devam gönderisi olarak bu yazıyı yayınlıyorum. Geçmiş yazı olan Instagram API ile Story İşlemleri yazımı okumanızı tavsiye etmekteyim. O yazıda temel olarak Instagram API'ı nasıl kullanacağınızı anlatan içerikler de mevcut.

Öncelikle Instagram API'ı kurmamız gerekmekte. İhtiyacınız olan şey sisteminize PHP 7.3.9 ve Composer kurulumlarını gerçekleştirmek. Bu işlemleri yaptıktan sonra yeni projemizi oluşturmaya başlayabiliriz.

Projemizin içinde bulunacağı klasörü oluşturun (Linux için mkdir <projeAdı> komutunu kullanabiliriz). Ardından terminal, konsol veyahut ne kullanıyorsanız o uygulamayı açın ve proje dizinine girdikten sonra (cd ), composer require mgp25/instagram-php komutu ile Instagram API dosyalarını projemize dahil edelim.

Bu işlemleri tamamladıktan sonra artık kodlarımızı yazacağımız dosyamızı oluşturabiliriz. Kendinize bir php dosyası açın (ör: instagram-islemleri.php). Dosyayı oluşturduktan sonra php taglarını açın ve yapmamız gereken bir kaç rutin işlem mevcut.

Composer aracılığı ile eklediğimiz kodların çalışması için ise require 'vendor/autoload.php'; komutunu girmemiz yeterli, bu satırı ekledikten sonra composer ile eklediğiniz tüm paketler sorunsuzca projenizde çalışmaya başlayacaktır.

Başlamak için gereken tüm işlemleri hallettiğimize göre işe koyulabiliriz. Öncelikle API unofficial yani gayriresmi olduğundan yazarı bizim riskleri kabul etmemizi istemiş. API classındaki kodların çalışabilmesi için \InstagramAPI\Instagram::$allowDangerousWebUsageAtMyOwnRisk = true; satırını kodumuza ekliyoruz. Artık API işlemlerini sorunsuzca gerçekleştirmeye başlayabiliriz.

Classımızdan yeni bir obje üretmek için $ig = new \InstagramAPI\Instagram(true, true); kodunu kullanıyoruz. Argümanların anlamlarını açıklamak gerekirse birinci argüman debug aktif ediyor ikinci argüman ise debugdaki gereksiz tüm kod parçacıklarını kısaltıyor (truncate). 

Giriş yapmak için bir try, catch bloğu tanımlayın. Catch bloğunun argümanı \Exception $e olursa kolayca hata yakalama işlemlerini gerçekleştirebiliriz. try bloğunun içerisine $ig->login($username, $password); komutunu yazdığınızda API'a login olacaksınız. 

Bu işlemlerin sonucunda hata almıyorsanız işlemlere devam edebiliriz.

Instagram API ile Fotoğraf, Video ve Albüm Yükleme İşlemleri

Yukarıdaki kod bloğunda tüm işlemler anlaşılır bir biçimde kodlanmıştır. Anlamadığınız kısımları yorum bölümünde belirtmekten çekinmeyiniz. İyi çalışmalar dilerim :)

Bugün Laravel'de one to many ilişkisi detaylı olarak nasıl kurulur bundan bahsedeceğim.

One to Many ilişkisi nedir?

One to Many ilişkisi bir varlığın bir şeye fazla sayıda sahip olabileceğini ancak o şeyin sadece tek kişiye ait olabileceğini gösteren ilişki türüdür. Örnek vermemiz gerekirse kullanıcı ve yazıları ele alalım. Bir yazının birden fazla yazarı yani kullanıcısı olamazken bir kullanıcı sonsuz sayıda yazı paylaşabilir. One to Many ilişkisi bu mantıkla ilerleyen tüm ilişkilerde kullanacağımız türdür. Bu ilişkiyi tanımlayıp kullanabilmemiz için sonsuz sayıda sahip olunabilinen girdi üzerinde kullanıcıya dair unique(tekil) bir değer teşkil eden sütunu foreign key(yabancı anahtar) olarak göstermemiz gerekmektedir.

One to Many ilişkisi nasıl kurulur?

• Öncelikle modellerinizi tanımlamanız gerekmektedir. Ben anlatımımda kullanıcı ve yazılar arasındaki ilişkiyi örnek göstererek ilerleyeceğim. Kullanıcı ve yazılar adında iki model açıp bunların fillable, guarded alanlarını tanımlayınız.
  
  
• Veritabanı migrationlarımızı oluşturalım. Kullanıcı migrationumuzda ekstra bir işlem yapmamıza gerek yok. Yazılar migrationumuzda işlemlerimizi yapmaya başlayalım.
  $table->unsignedBigInteger('user_id'); komutu ile foreign keyimizin bulunacağı sütunu açıyoruz. Burada model ismine göre oluşturmanızda fayda bulunmaktadır.
  
  
• Yazılar migrationumuzda foreign key sütunumuzu tanımladıktan sonra $table->foreign('user_id')->references('id')->on('users'); kod bloğunu kullanarak foreign keyimizin özelliklerini tanımlıyoruz.
  
  
• Daha detaylı yaklaşmak gerekirse $table->foreign('key_ismi') foreign keyimizin adını göstermektedir. ->references('id') kısmı ise ilişkiyi kuracağımız diğer tablodaki hangi sütunu işaret ettiğimizi belirliyor. ->on('tablo_ismi') kısmı ise hangi tabloya bakması gerektiğini gösteriyor.
  
  
• Migration üzerinde foreign key ilişkilerini tamamladıktan sonra kullanıcı modeli yani tekil olan modele geliyoruz. Alttaki kod bloğu ile ilişkiyi tamamlıyoruz:
  public function post()
{
   return $this->hasMany(\App\User\Post::class, 'user_id');
}
  
  
• Yukarıdaki kod bloğunu açıklayacak olursak post fonksiyonu Eloquent hasMany ilişkisini döndüren bir fonksiyon çağırmakta. hasMany fonksiyonunun ilk argümanı hangi modeli kontrol edeceğinizi, ikinci argümansa o model için veritabanınızda hangi isimle foreign key oluşturduğunuzu gösteriyor.
  
  
• Bu işlemleri tamamladıktan sonra örnek erişim için User::where('id', $id)->first()->post()->all() komutunu kullanarak tüm kullanıcıyla bağdaştırılmış yazıları getirebilirsiniz.
  
  
• Örnek bir yazı oluştururken de controllerınızın store fonksiyonu zaten id alıyor, bu id'yi yazılar modelinizde fillable olarak gösterirseniz yeni bir yazı oluşturduğunuzda 'user_id' => $id şeklinde gönderdiğinizde ilişki kurulmuş olacak.

Umarım anlamanıza yardımcı olmuşumdur, anlamadığınız kısımları yorum bölümünde belirtirseniz yanıtlayacağım. Laravel ile ilgili daha fazla yazı okumak istiyorsanız Laravel Artisan Komutları makaleme de göz atmanızı öneririm.

Uzun süre macOS kullanıp da başka bir işletim sistemine geçenler varsa yazı tiplerinin daha çirkin durduğunu farkedecektir. Sebebi hem macOS'da kullanılan font yumuşatma ayarları hem de sistem üzerinde kullanılan fontun türü.

Şimdi Linux üzerinde font yumuşatmaları nasıl kurabileceğimize bakalım. Öncelikle kendi sistemimden bir fotoğraf atarak göstermek istiyorum.

Gördüğünüz üzere sistem yazı tipleri, başlıkların yazı tipleri çok düzgün ve pürüzsüz gözükmekte. Şimdi ayarlarını nasıl yapabileceğinize geçelim.

• Sistemin genel font ayarlarına giriyoruz.
• İnternet üzerinden San Francisco Display Medium fontunu ttf formatında ediniyoruz. (Link veremiyorum, yasal değil.)
• Sistem geneli kurulumunu gerçekleştiriyoruz, ardından seçeneklerden SF Pro Display Medium fontunu 10.5pt olarak seçiyoruz.
• Antialiasing ayarını açıyoruz.
• Sub-pixel rendering ayarını RGB olarak seçiyoruz.
• Hinting ayarını none olarak seçiyoruz.
• Font DPI boyutunu 96 olarak ayarlıyoruz.

Bu işlemleri KDE ve GNOME masaüstü ortamlarında kolaylıkla yapabilirsiniz. Eğer iki ortamdan birini kullanmıyorsanız .Xresources dosyasının nasıl kullanıldığını araştırabilir, kendi sisteminizde de işlemleri o dosya aracılığı ile yapabilirsiniz.

Bir arkadaşımın isteği üzerine Instagram API aracılığı ile story yani hikayeler üzerinde birkaç işlem yapmam gerekti. Bu sebepten ötürü PHP ile Instagram API işlemlerini öğrenmeye karar verdim.

Yapmak istediği şey storylerini gören insanların listesini bir veritabanına kaydetmekti. Tam olarak işlemleri bitirmemiş olsam da API'ın kullanımını temel olarak anlatıp basit işlemleri nasıl yapacağımızı anlatacağım.

Öncelikle Instagram API'ı kurmamız gerekmekte. İhtiyacınız olan şey sisteminize PHP 7.3.9 ve Composer kurulumlarını gerçekleştirmek. Bu işlemleri yaptıktan sonra yeni projemizi oluşturmaya başlayabiliriz.

Projemizin içinde bulunacağı klasörü oluşturun (Linux için mkdir <projeAdı> komutunu kullanabiliriz). Ardından terminal, konsol veyahut ne kullanıyorsanız o uygulamayı açın ve proje dizinine girdikten sonra (cd ), composer require mgp25/instagram-php komutu ile Instagram API dosyalarını projemize dahil edelim.

Bu işlemleri tamamladıktan sonra artık kodlarımızı yazacağımız dosyamızı oluşturabiliriz. Kendinize bir php dosyası açın (ör: instagram-islemleri.php). Dosyayı oluşturduktan sonra php taglarını açın ve yapmamız gereken bir kaç rutin işlem mevcut.

Öncelikle hata kodlarını görmemiz gerekecek. Lokal sunucunun 500 hatası vermeden hataları göstermesi için:

error_reporting(E_ALL);
ini_set('display_errors', 'On');

komutlarını php taglarımız arasına ekliyoruz. Bu bütün hataları görmemizi ve düzenlememizi sağlayacak.

Composer aracılığı ile eklediğimiz kodların çalışması için ise require 'vendor/autoload.php'; komutunu girmemiz yeterli, bu satırı ekledikten sonra composer ile eklediğiniz tüm paketler sorunsuzca projenizde çalışmaya başlayacaktır.

Başlamak için gereken tüm işlemleri hallettiğimize göre işe koyulabiliriz. Öncelikle API unofficial yani gayriresmi olduğundan yazarı bizim riskleri kabul etmemizi istemiş. API classındaki kodların çalışabilmesi için \InstagramAPI\Instagram::$allowDangerousWebUsageAtMyOwnRisk = true; satırını kodumuza ekliyoruz. Artık API işlemlerini sorunsuzca gerçekleştirmeye başlayabiliriz.

Classımızdan yeni bir obje üretmek için $ig = new \InstagramAPI\Instagram(true, true); kodunu kullanıyoruz. Argümanların anlamlarını açıklamak gerekirse birinci argüman debug aktif ediyor ikinci argüman ise debugdaki gereksiz tüm kod parçacıklarını kısaltıyor (truncate). 

Bu işlemi de tamamladıktan sonra artık giriş yapmaya geçebiliriz ama yapmamız gereken bir şey var, development işlemlerini hangi hesabınız ile gerçekleştirecekseniz bu adresten Instagram Developer User ID'nizi öğrenmeniz gerekmektedir.

User ID'yi edindiğimize göre üç değişken oluşturalım bunlar $username, $password, $user_id değişkenleri olabilir. İsimleri Türkçe veya İngilizce olarak siz seçebilirsiniz ($kullanici_adi, $sifre, $kullanici_id). Bu değişkenlerin içeriğini stringler ile tanımlayarak yazmanız gerekmekte. (ör: $username = 'dogukan.jpg')

Giriş yapmak için bir try, catch bloğu tanımlayın. Catch bloğunun argümanı \Exception $e olursa kolayca hata yakalama işlemlerini gerçekleştirebiliriz. try bloğunun içerisine $ig->login($username, $password); komutunu yazdığınızda API'a login olacaksınız. 

Tüm işlemleri yaptığımıza göre sayfayı yenilediğinizde hata almıyorsanız story yani hikayeler ile oynamaya başlayabiliriz. Benim yapmak istediğim giriş yaptığım kullanıcının hikayelerini alıp o hikayeleri izleyen kişileri veritabanına kaydetmek olduğundan bunun için gereken temel komutlara bir göz atalım.

Instagram API Hikaye (Story) İşlemleri

• Takip ettiğiniz kişilerin hikayelerini görmek için:
  $ig->story->getReelsTrayFeed();
  
  
• Kullanıcının hikayelerini görmek için:
  $ig->story->getUserReelMediaFeed('user_id');
  _{* Yukarıda belirttiğim şekilde aldığımız user_id'den bahsediliyor.}
  
  
• Hikayenize bakan kişileri görmek için:
  $ig->story->getStoryItemViewers('story_id');
  _{* story_id parametresini getUserReelMediaFeed fonksiyonu ile alacağız. Makalenin devamında bahsedeceğim.}
  

Örnek olarak giriş yapıp storyleri aldığım ve onlardan gelen kullanıcıları bastırdığım açıklamalı kodu inceleyebilirsiniz.

Sorularınız için yorum bölümüne başvurabilirsiniz. Instagram API hakkında yeni makaleler ekleyeceğim. Sıradaki planım mesaj işlemlerini detaylı olarak örnekli anlatmak. Okuduğunuz için teşekkür ederim.

Sistemim üzerinde macOS kullanmak istediğimden ancak bir Macbook da satın almak istemediğimden Hackintosh konusu ilgimi çekti. Ben de araştırmalar yapmaya başladım. Bu rehberi yazarken öncelikle osxinfo.net forumundaki herkese çok teşekkür ediyorum, başarılı bir kurulum gerçekleştirmemi sağladılar. İsterseniz kurulum aşamasına geçelim.

İlk olarak https://sourceforge.net/projects/voodoohda/ adresinden VoodooHDA'nın en güncel sürüm kextini indiriyoruz.

Ardından sistemimizden AppleHDA.kext dosyasını kaldırmamız gerekmekte, aksi halde VoodooHDA aktif olmayacaktır. Bu işlemi gerçekleştirmek için terminali açıyoruz ve aşağıdaki komutu giriyoruz.

sudo rm -r /System/Library/Extensions/AppleHDA.kext/

Bu işlemi tamamladıktan sonra herhangi bir kext yükleme programı ile VoodooHDA.kext dosyasını sisteminize kurmanız gerekiyor. Ben kext yükleme programı için KCPM Utility Proyu tercih ediyorum. Bu linkten programı edinebilirsiniz.

Programın ayarlarını fotoğraftaki gibi yapıyoruz. /Library/Extensions seçeneğinin seçilmiş olması önemlidir. Ardından gördüğümüz EZ Mode Enabled yazısının oraya VoodooHDA.kext dosyasını sürüklüyoruz. İşlemler otomatik olarak yapılıyor, kextcache yeniden build ediliyor. AppleHDA'nın silme işlemi de bu şekilde tamamlanmış oluyor.

Sonuç olarak sistemi yeniden başlattığımızda problemsiz olarak sesiniz aktifleşmiş olacaktır. Hackintoshunuzda müzik dinlemenin keyfini çıkartın :)

Bugün Laravel'de karşılaştığım zvalIsRef hatasının çözümünü anlatacağım. Hata ile karşılaşırsanız yazdığınız kod eğer hatalıysa bu hatayı alacaksınız ve nerede yanlış yaptığınızı farkedemeyeceksiniz.

Projemde bunu düzeltmek için dosyaları tek tek elle girdim, kodları sıfırdan yazmaya çalıştım gibi gibi ancak sorun çözülmedi.

Problemin çözümü aslında çok basit. Laravel 5.8 sürümü PHP 8.0 ve 7.4 ile çalışmıyor. PHP sürümünüzü 7.3.9'a düşürürseniz projeniz problemsiz şekilde çalışacak, hataları gösterecektir.

Arch Linux üzerine gelen yeni güncelleme ile xf86-input-synaptics paketi kaldırıldığından Elantech marka touchpad kullanan bilgisayarlarda touchpad çalışmamaya başladı.

Bilgisayarım MSI GS73VR bu hatadan nemalanınca problemi araştırmaya başladım. İlk önce eski paketi kaldırarak başladım, pacman üzerinden logları inceleyerek neler update edilmiş onları inceledim. Libinput paketini ve çeşitli paketleri downgrade ettim ancak problem bir türlü çözülmedi.

rmmod psmouse ve modprobe psmouse proto=imps yazmak touchpadi çalıştırsa da kullanılmaz bir haldeydi. Çoklu dokunuş desteğini kazandırmam gerekiyordu.

bugs.archlinux.org üzerinde yürüttüğüm araştırmalarda benim gibi bir çok kullanıcının problemi yaşadığını gördüm. Çok basit bir çözümle sorunu halledebilirsiniz. (ps. Commands that written below fixes the touchpad issue)

yay -R xf86-input-synaptics

options psmouse elantech_smbus=0 synaptics_intertouch=0 >> /etc/modprobe.d/elan.conf  (root olarak çalıştırın)

Sisteminizi yeniden başlattığınızda problem çözülecektir. 

Kaynak: https://bugs.archlinux.org/task/63525

Sitemin veritabanının yedeğini almıştım ve başka bir ortama taşımam gerekiyordu. Dosyaları taşıdım, veritabanını oluşturdum, SQL dump aldıktan sonra yeni sunucuya yükledim ki bu hata oluştu. (#1071 - Specified key was too long; max key length is 767 bytes)

Bu hata büyük ihtimal ile Laravel uygulamalarınızda karşınıza çıkacak. Uzun uğraşlar sonucu sorunu çözdüm. İlk olarak halihazırdaki veritabanlarınız için çözümü sunacağım, ikinci yol olaraksa veritabanı oluşturulmamış Laravel uygulamalarınızda bu hata ile asla karşılaşmamanızı sağlayacağım. Test etmediğim ancak işe yaradığından bahsedilen üçüncü bir yol daha göstereceğim.

MySQL veya MariaDB sürümünü yükseltmek

Evet hatanın ilk çözümü bu. Sunucunuzdaki MySQL sürümü 5.7.7 ve altındaysa, MariaDB de 10.2.2 ve altındaysa bu hatayla karşılaşacaksınız. 

Güncelleme yapmak için örnek olarak CentOS 7.5 MariaDB 10.1'den 10.4'e nasıl güncelleyeceğinizi göstereceğim.

systemctl stop mysql

yum -y remove mariadb-server

sed -i 's|10.1|10.4|g' /etc/yum.repos.d/MariaDB.repo

yum -y install mariadb-server

systemctl start mysql

mysql_upgrade -u root -p 

komutlarını sırasıyla çalıştırdığımızda MariaDB güncellenecektir.

Laravel Framework defaultStringLength Düzenleme

Laravel'de Schema classına tanımlanmış varsayılan string uzunluğunu değiştirerek bu problemi çözebiliriz.

app/Providers/AppServiceProvider.php dosyasını düzenliyoruz.

use Illuminate\Support\Facades\Schema;

public function boot() {
    Schema::defaultStringLength(191);
}

eklemesini yaptığımızda bundan sonra projelerinizde problem çıkmayacaktır.

Hatanın oluşma sebebi Laravel varsayılan olarak emojileri de veritabanında saklayan utf8mb4 karakter setini kullandığı için bu karakter setinin ürettiği string uzunluklarını eski sürümler destekleyemeyebiliyor. Hatanın düzenlenmesi için AppServiceProviderınızda bu düzenlemeyi yaptıktan sonra tekrar migrate etmeniz gerekiyor.

innodb_large_prefix özelliğini etkinleştirmek

my.ini dosyanızı açıp aşağıdaki satırları içerisine ekleyin. Dosyanın konumu sisteminize göre değişiklik gösterebilir.

[mysqld]
innodb_file_format = Barracuda
innodb_large_prefix = 1
innodb_file_per_table = ON

Probleminiz çözülmediyse yorumlar bölümünde belirtebilirsiniz, yardımcı olmaya çalışacağım.

CyberPanel kurulumu oldukça basittir. Kurulumu "root" hesap olarak çalıştırmalısınız.

Sistem gereksinimleri

• CentOS 7.x (minimal versiyon tavsiye edilir)
• Python 2.7
• 1024MB minimum RAM
• 10GB minimum disk

Cyberpanel kurulumu

Cyberpanel'i tek komut ile kurabilirsiniz. Kurmak için root olarak login olduğunuz sisteminizde bu komutu çalıştırın:

sh <(curl https://cyberpanel.net/install.sh || wget -O - https://cyberpanel.net/install.sh)

Gerekli adımları izledikten sonra paneliniz kullanıma hazır!

Nasıl kullanılır?

https://:8090
Kullanıcı adı: admin
Şifre: 1234567

Kuruluma başlangıç

Xorg kurulumu

Xorg video server görevini yapan, CLI yerine GUI işlemlerini gerçekleştiren altyapımız.

yay -S xorg-server komutu ile kurulumu gerçekleştirilebilir.

Video driver kurulumu

Intel GPU'lar için örnek olarak alttaki kurulumu izleyebiliriniz. Laptopunuza kuruyorsanız zaten tek seçeneğiniz bu.

yay -S xf86-video-intel mesa komutu ile driver kurulumunu yapıyoruz.

SDDM kurulumu (greeter, login ekranı)

SDDM her sistem başlangıcında size login ekranı sunan servis yazılımıdır.

• yay -S sddm
• systemctl enable sddm
• systemctl start sddm

KDE Plasma kurulumu

Plasma kurulumunu gerçekleştirelim. Evet siz de biliyorsunuz en iyisi KDE :)

pacman -S plasma komutu ile kurulumu yapalım. Default seçenekler ile ilerleyin.

NetworkManager ile ağ yönetimi

NetworkManager ve plasma-nm kurulumunu yapalım.

pacman -S networkmanager ve pacman -S plasma-nm ile kurulumları yapalım.

Tüm KDE uygulamalarının kurulumu

Tüm KDE uygulamalarını kurmak için pacman -S kde-applications-meta komutunu kullanalım.İstediğiniz uygulamaları seçebilirsiniz.

Chrome kurulumu

pacman -S chromium ile Chrome kurulumu yapabilirsiniz.

KDE Plasma kurulumu tamamlanmıştır. Sistemde çıkan problemler hakkında yorum atarsanız yardımcı olacağım ayrıca eksik gördüğünüz kısımları da belirtirseniz makaleyi güncellemekten mutluluk duyarım.

Daha öncesinde yazdığım TCMB Döviz Kuru çevirici PHP fonksiyonunu sizlerle paylaşmak istiyorum. Kolay anlaşılabilmesi için bloklara böldüm ve her blok için açıklama satırları yazdım.

Fonksiyonu kullanabilmek için:
TCMB_Converter('from', 'to', value);

Örnek kullanım:
TCMB_Converter('TRY', 'USD', 100);

İyi kullanımlar.

Laravel ile bir uygulama yazdınız ancak paylaşımlı bir hostingde mi kullanacaksınız? Büyük ihtimal ile Artisan komutlarını çalıştırmadan uygulamanızı düzgün şekilde kullanamayacaksınız. Artisan komutlarını çağırmak için yapmanız gereken işlemler aslında çok basit.

Route::get('/admin/artisan-route-cache', function() {
    Artisan::call('route:cache');
});

Örnek bir rota içerisinde Artisan::call(''); şeklinde kullanımını gördük. Bu şekilde kolayca Artisan komutlarını çalıştırabilirsiniz. 

ÖNEMLİ: Bunları admin panelinizde düğmeler olarak ekleyecekseniz bir middleware içerisinde kontrol ettirmenizde fayda var. Önemli komutları açık halde bırakırsanız tehlikeli durumlar yaratabilir.

Middleware ile nasıl kontrol ederim?

Route::group(['middleware' => ['auth', 'CheckIfAdmin']], function() {
    Route::get('/admin/artisan-route-cache', function() {
        Artisan::call('route:cache');
    });
});

Yaptığımız şey benim özel yazdığım CheckIfAdmin middlewareından ve auth middlewareından geçirmek oldu. Böylece dışarıdan kullanıcılar bu linki bilse bile erişim sağlayamayacak.

İyi kodlamalar!

Artisan Laravel paketine dahil olarak gelen komut satırı aracıdır(CLI). Laravel projelerinizi oluştururken fazlasıyla kullanacağınız, işleri kolaylaştıran bir araçtır.

Laravel Artisan nasıl kullanılır?

php artisan [seçenek] [argümanlar] şeklinde çalıştırılmaktadır. Çalışması için proje dizininde olmanız gerekmektedir ve sisteminizde PHP kurulu olmalıdır.

Artisan komutları

• php artisan list
  Artisan üzerinde kullanabileceğiniz tüm komutları listeler.
  
  
• php artisan --version
  Laravel uygulamanızın sürümünü gösterir.
  
  
• php artisan down
  Uygulamanızı bakım moduna alır.
  
  
• php artisan env
  Bulunduğunuz "environment"i gösterir.
  
  
• php artisan migrate
  Veritabanı eşitleme işlemlerini yapar.
  
  
• php artisan migrate:rollback
  Veritabanında yaptığınız değişiklikleri adım adım geri alır.
  
  
• php artisan migrate:refresh
  Bütün yaptığınız değişiklikleri geri alır ve veritabanını yeniden yükler. (Verileriniz silinir)
• php artisan migrate:refresh --seed
  Refresh işlemini aynen gerçekleştirir ve database seederlarını da çalıştırır.
  
  
• php artisan serve
  Uygulamanızı başlatır.
  
  
• php artisan up
  Uygulamanızı bakım modundan çıkartır.
  
  
• php artisan cache:clear
  Uygulama önbelleğini temizler.
  
  
• php artisan cache:table
  Uygulamanızda veritabanı için önbellekleme oluşturur.
  
  
• php artisan config:cache
  Konfigürasyon dosyanızı hızlı yükleme için önbellekler.
  
  
• php artisan config:clear
  Konfigürasyon önbelleğini temizler.
  
  
• php artisan make:auth
  Laravel'in içerisinde gelen hazır kullanıcı sistemini uygulamanıza ekler.
  
  
• php artisan make:controller <Dizin/ControllerAdı>
  Sizin için istediğiniz isimde hazır bir controller oluşturur.
  
  
• php artisan make:controller <Dizin/ControllerAdı> --resource
  Hazır controller kalıbı ile controller oluşturmanızı sağlar.
  
  
• php artisan make:migration <MigrationAdı>
  Veritabanı için migration dosyası oluşturur.
  
  
• php artisan make:model <ModelAdı>
  Yeni bir Eloquent model nesnesi oluşturur.
  
  
• php artisan route:list
  Eklediğiniz ve vendor uygulamaların eklediği rotaları listeler.
  
  
• php artisan route:clear
  Rota önbelleğini temizler.
  
  
• php artisan route:cache
  Rotaları hızlı yükleme için önbellekler.
  
  
• php artisan view:clear
  Derlenmiş önyüz dosyalarını temizler. Bazen değişiklikler sayfada gözükmeyince gereklidir.

Öncelikle Arch ISO indirmemiz gerekiyor.

https://www.archlinux.org/download/ adresinden Direct download kısmından kendinize uyan isoyu indirip Rufus (https://rufus.ie/), BalenaEtcher gibi yazılımlar ile bootable flash oluşturabilirsiniz. GPT modunu seçmeniz gerekmektedir. İmajı oluşturduktan sonra sisteminizi flashtan boot etmeniz gerek, ancak Secure Boot seçeneğini devre dışı bırakmalısınız. 

Boot ettikten sonra göreceğimiz manzara:

İlk seçeneği seçerek siyah korkunç(!) kurulum ekranımızı başlatıyoruz.

Google'u pingleyerek internetimiz var mı diye kontrol ediyoruz, kurulum boyunca bir ethernet bağlantısına ihtiyacınız var. Ping çıkıyorsa sorun yok demektir, devam ediyoruz.

fdisk -l komutu ile tüm disklerimizi görüyoruz, biz /dev/sda üzerine kurulum yapacağız. Dualboot için yapmanız gereken işlemleri ayrı bir makale olarak yazacağım.

Diskimizdeki alanları gördüğümüze göre, cfdisk komutu ile diskimizi ayarlamaya başlıyoruz.

GPT'yi seçerek ilerliyoruz.

İlk önce New kısmına gelerek 512M yazıp 512mblik bir EFI/BIOS boot bölümü oluşturuyoruz. Oluşturduktan sonra Type kısmına girip sisteminiz EFI ise EFI System seçeneğini, değilse BIOS boot seçeneğini seçiniz.

*Güncelleme 26.03.2020: EFI kurulum yaparken 16M'lik bir BIOS boot bölümü ekleyin*

Diğer bölümümüzü de istediğimiz boyutta oluşturuyoruz, zaten otomatik olarak Linux filesystem ibaresi gelecektir. Type seçmemize gerek yok. İşlemi tamamladıktan sonra Write seçeneğini seçerek diske partition table'ı yazıyoruz.

fdisk ile tekrar kontrol ettiğimizde /dev/sda1 için boot bölümümüzün, /dev/sda2 için Linux sistemimizin bölündüğünü teyit etmiş olduk. Şimdi partitionları formatlamamız gerekiyor. Ben ext4 tercih ettiğim için iki partitionu da ext4 olarak biçimlendireceğim.

mkfs.ext4 /dev/sda1 26.03.2020 itibariyle geçersiz

mkfs.ext4 /dev/sda2

mkfs.vfat -F32 /dev/sda1

komutlarını kullanarak sistemimizi biçimlendirip mount etmeye hazır hale getirdik.

mount /dev/sda2 /mnt

mkdir /mnt/boot

mount /dev/sda1 /mnt/boot

komutlarını yazarak işletim sistemi için gerekli alanları mount ediyoruz. Resimde yanlışlık olmuş, dikkate almayınız.

pacstrap /mnt base base-devel

komutunu kullanarak sistemimizi yüklemeye başlıyoruz.

pacstrap işlemi tamamlandıktan sonra genfstab -U /mnt >> /mnt/etc/fstab komutunu yazarak başlangıçta sistemin mount edilmesini sağlıyoruz. (resimde yanlışlık var)

arch-chroot /mnt komutunu kullanarak kurduğumuz sistemi Live ISO üzerinde kullanabiliyoruz ve işlemler yapacağız.

ln -sf /usr/share/zoneinfo/Europe/Istanbul /etc/localtime

hwclock --systohc

locale-gen

LANG=tr_TR.UTF-8 >> /etc/locale.conf

loadkeys trq

komutları ile gerekli işlemleri gerçekleştiriyoruz. Temel olarak yerelleştirme işlemlerini yapıyor.

nano /etc/hostname komutunu kullanıp içeriye sisteminizin hostnameini yazınız.

nano /etc/hosts komutunu kullanıp host dosyamızı açıyoruz ve içerisine resimde gördüğümüz şeyleri yazıyoruz. divergent yerine kendi hostname'inizi yazmanız gerekmektedir.

mkinitcpio -p linux komutunu çalıştırarak sistemimizi bootable hale getiriyoruz.

*Güncelleme 26.03.2020: pacman -S mkinitcpio linux linux-firmware komutunu çalıştırarak sistemimizi bootable hale getiriyoruz.

passwd komutunu yazarak root hesabınız için şifrenizi belirleyin.

Yeni kullanıcı hesabı da oluşturmamız gerekiyor. Aşağıdaki komutları girerek oluşturalım.

• nano /etc/sudoers komutunu kullanarak içerideki %wheel ALL=(ALL) ALL gördüğümüz satırın başındaki # işaretini kaldırıyoruz ve kaydediyoruz.
• useradd -m -G wheel -s /bin/bash KULLANICIADI komutunu kullanarak kullanıcı hesabımızı yaratıyoruz.
• passwd KULLANICIADI komutu ile kullanıcımıza şifre belirliyoruz.

Eğer hata mesajı almadıysak kullanıcımız başarıyla oluşturulmuştur.

pacman -S grub komutu ile GRUB bootloaderi kuruyoruz.

grub-install --target=i386-pc /dev/sda komutu ile GRUB bootladerin sistemimize kurulumunu gerçekleştiriyoruz.

grub-mkconfig -o /boot/grub/grub.cfg komutu ile GRUB configini yaratıyoruz.

*Güncelleme 26.03.2020: pacman -S dhcpcd komutu ile dhcp servisini kuruyoruz, bir dahaki bootta internete ihtiyacımız olacak.

Karşımızda Arch Linux! Kurulu bir şekilde hem de.

Evet, internetimiz yoktu. Nasıl getireceğiz? Sırasıyla ethernet kablonuz bağlıyken:

• ip link
• dhcpcd

komutlarını çalıştırın ve ping atabildiğinizi göreceksiniz.

AUR helper olan yay yazılımını kurabilmek için git paketine ihtiyacımız var. pacman -S git komutu ile kurulumu gerçekleştirebilirsiniz ancak sizin sisteme root olarak değil oluşturduğunuz kullanıcı ile giriş yapmanız gerekiyor.

git clone https://aur.archlinux.org/yay.git komutunu kullanarak yay aur helper yazılımını sistemimize kurmak üzere indiriyoruz, indirme tamamlandıktan sonra cd yay komutunu yazarak dizine geçiyoruz ve makepkg -si komutu ile kuruluma başlıyoruz.

Sonunda! Kurulum tamamlanmıştır, bundan sonra isterseniz internetten araştırarak KDE, xfce4, deepin gibi DE'lerden birini kurup ilerleyebilirsiniz. Yakında arayüz kurulumu ve dualboot kurulum için de rehber yayınlayacağım. Eğer yayınlanırsa buraya linkleri koyacağım, takibi bırakmayın!

Düzenleme 7 Ağustos 2019: KDE Plasma Kurulumu rehberimiz yayınlanmıştır.

Siz de bir web developersiniz ve Arch üzerinde nasıl bir LAMP stack kuracağınızı öğrenmek istiyorsanız: Devilbox ile LAMP Stack Kurulumu

Devilbox, Docker Container sistemini kullanarak sisteminize LAMP Stack kurulumu yapmanızı sağlayan bir kurulum paketidir. Kullanımı ve konfigürasyonu kolaydır.

Kurulum tamamlandıktan sonra böyle bir arayüze sahip olacağız. Kurulum Windows ve Mac için de mevcutken bugün Linux için anlatacağım.

Öncelikle sisteminizde docker ve docker-compose paketlerinin bulunması lazım. Ben Archlinux kullandığımdan (eğer kurmak istiyorsanız Arch Linux Kurulumu Resimli Anlatım) buranın paket yönetim sistemi üzerinden komutları vereceğim, siz de sisteminize uygun paket yöneticisi ile bu paketleri kurabilirsiniz.

yay -S docker docker-compose

komutu ile gerekli paketleri kuruyoruz.

Sıradaki adım olarak devilbox'u indirmemiz gerekiyor. Bunun için home dizininize geçiniz (cd ~). Ardından aşağıdaki komut ile devilbox reposunu sistemimize kopyalamamız gerekiyor.

git clone https://github.com/cytopia/devilbox

İşlemler tamamlandıktan sonra bulunduğunuz dizinde devilbox isimli bir klasör oluşmuş olmalı gerekiyor. Eğer oluştuysa bu dizine geçiş yapıyoruz ve .env dosyamızı oluşturmak için aşağıdaki komutu yazıyoruz.

cp env-example .env

.env dosyamızı düzenlemeye başlayabiliriz. Bu dosyada düzenlemeniz gereken kritik satırlar:

• TLD_SUFFIX
  bind serverin domain uzantılarını belirler, projeadi.SUFFIX şeklinde domainleriniz otomatik oluşacaktır.
  
  
• TIMEZONE
  Bu ayarı Europe/Istanbul olarak ayarlamanız gerekmektedir.
  
  
• DEVILBOX_UI_ENABLE
  Bu ayarı 1 yapmanız gerekiyor. devilbox adresini size erişilebilir kılacak, resmini eklediğim panele sahip olacak buradan databaselerinizi yönetebileceksiniz.
  
  
• İmajlar
  Burası tamamen sizin stack tercihinize kalmış, baştaki # işaretini kaldırarak seçim yapabilir, o containerleri indirmesini sağlayabilirsiniz.
  
  
• HTTPD Docker Settings
  Buradan varsayılan docroot ayarlarınızı, portlarınızı vs. değiştirebilirsiniz
  
  
• MySQL Docker Settings
  MySQL veritabanınıza şifre ekleyebilirsiniz.

.env dosyamızdaki ayarları tamamladığımıza göre artık makineyi çalıştırabiliriz. Yapmamız gereken iki işlem var. Docker Containerlerini çalıştırmak için:

docker-compose up -d

Ardından projelerinizi devilbox/data/www altında klasörlendirerek açabilirsiniz. Açtığınız klasör içerisinde docroot ayarınıza göre bir klasör açmanız daha gerekecektir. (varsayılan olarak public_html)

Klasörünüzü açtıktan sonra örneğin eticaret klasörü açtıysanız eticaret.SUFFIX tarzında erişim sağlamak için sisteminizin host dosyasına 127.0.0.1 eticaret.SUFFIX yazıp kaydetmeniz gerekmektedir.

Index of / yazısını gördüğünüzde sistem tamamen hazır demektir. İyi kullanımlar dilerim :)

Sorularınızı yorum bölümünde belirtirseniz yardımcı olacağım.

Merhaba dünya!

Tekrardan ben geldim. Evet, uzun yıllar oldu blog yazmayalı... Blog yazmadığım süreç 5 yılı geçti ancak hayatımda hep bir eksiklik hissettim. İnsanlara öğrendiğim şeyleri paylaşacak, bir şeyler öğretecek bir platformun eksikliğini hissettim.

Laravel ile tecrübe edinmek için bir içerik yönetim sistemi geliştirdikten sonra neden yapmıyorum ki dedim kendime. İlk önce eski alan adım olan www.dogukanoksuz.com.tr adresini değiştirmek istedim, blog yazmaya çok uygun değilmiş gibi geldi. İsim arayışında bulunurken kendimi .dev domain uzantısının içerisinde buldum ve ismimin geçtiği www.dogukan.dev domaininin boş olduğunu görmemle hevesim iyice arttı, projeye dört elle sarılarak hızlıca geliştirdim.

Eee, websitende ne yazmayı planlıyorsun, kişisel bir blog mu olacak? sorusuna cevabım ise blogumda bilgisayar dünyası ile alakalı karşılaştığım sorunların çözümlerinden bahsetmeyi planlıyorum. Genel olarak hangi konular derseniz:

• Linux
• PHP
• C++
• Python
• Windows Sistemler
• IT problemleri

ve diğer aklıma gelmeyen konular...

Peki bunları yapınca ne elde edeceksin? sorusunun da yöneltildiğini hisseder gibiyim, bu sebepten buna da yanıt vereyim. Bir bilgisayar mühendisliği öğrencisi olarak Türkçe kaynak bulmakta güçlük çekiyor, bütün araştırmalarımı İngilizce yapmak zorunda kalıyorum. Bu sebepten ötürü insanların kolay bilgiye erişimini sağlamak için yapacağım ancak ufak bir artısı da yok değil. Blog yazarken, insanlara bir şey anlatırken o konu hakkında detaylı bilgiye sahip olacağım ve daha çok araştırmam gerekecek. Bu sayede kendimi daha da geliştirebileceğim. Umarım herkese faydalı olabilirim.

Bu arada projeyi geliştirirken arkamda bulunan abim Mehmet Akif Öksüz'e ve Creentech'ten Mert Yakan'a teşekkürlerimi iletiyorum. 

Okuyan herkese teşekkür ediyor, iyi günler diliyorum.