Hajto

def edit(conn, %{ "edit" => newData }) do
    #TODO: naprawic to
    case Repo.one(User.unique_user(User, "login")) do
      nil -> conn
        |> put_flash(:error, "Błąd bazy danych")
      result ->
        if Map.get(newData, "password") == "" do
          newData = Map.put(newData,"password", result.password)
        end
        if Map.get(newData, "avatar") == "" do

Hajto

  def show_details(conn, _params) do
    name_param = Map.get(_params, "name")
    permission_level = get_session(conn, :role)
    case permission_level do
      User.student ->
        session_login = get_session(conn, :login)
        IO.inspect(session_login)
        IO.inspect(name_param)
        case name_param do
          ^session_login ->

Hajto

/*
Zrodla :
http://www.cplusplus.com/reference/stack/stack/push/
http://www.cplusplus.com/reference/string/string/

Opublikowano na pastebin.com

Dlaczego unsigned ? - bo nie niesie za soba, bo wymaga bardzo malo pamieci
Dlaczego stack ? - bo chcialem sprawdzic jak to dziala

Hajto

defmodule Hangman.CategoryController do
  use Hangman.Web, :controller

  alias Hangman.Category

  def create(conn, %{ "category" => params }) do
    IO.inspect(params)
    a = Category.changeset(%Category{},params)
    Repo.insert(a)
    text(conn, a.valid?)

Hajto

defmodule Hangman.MasterCatController do
  use Hangman.Web, :controller

  alias Hangman.MasterCat

  def index(conn, _params) do
    query = from p in MasterCat,
         select: p

    a = Repo.all(query)

Hajto

def authorized(block : (User) => Future[Result] )(implicit req : Request[_]) : Future[Result] = {
    req.session.get(USER_CACHE).map { session =>
      val user = Cache.getAs[User](USER_CACHE)
      if (user.isEmpty) {
        Database.users.find(Json.obj(USER_CACHE -> session)).one[User].flatMap[Result] { r => r.map { res =>
          val u = res.copy(password = "****")
          Cache.set(USER_CACHE,u, 1.hour)
          block(u)
          }.get
        } fallbackTo Future.successful(InternalServerError)

Hajto

package model

import play.api.data.Form
import play.api.libs.json.Json
import model.SkillFormats.skillRecordFormat
import play.api.data._
import play.api.data.Forms._

object UserFormats {
  implicit val userForm = Form(

Hajto

defmodule Andrzej do
  def getData(s), do: String.replace(IO.gets(s),"\n","")
  def gIndex(list,elem), do: Enum.find_index(list, fn x -> x == elem end)
  def testCombinator (listS) do
    x = [" pierwsza forma "," druga forma "," trzecia forma ", " polski "]
    listP = List.zip([x,listS])
    Enum.map(listS, fn a -> Enum.map(listP,
      fn {b,c} ->
        unless gIndex(listS,a) == gIndex(x,b) do
          getData(a <> "=>" <> b) == c

Hajto

package objsets

import common._
import TweetReader._

/**
 * A class to represent tweets.
 */
class Tweet(val user: String, val text: String, val retweets: Int) {
  override def toString: String =

Hajto

selectMaps($()).map { elem =>
      elem.map { jsValue =>
        jsValue.validate[Level].get
      }: List[Level]
    }.collect {
      case (list: List[Level]) => Ok(views.html.levelChooser(list))
    }