             },
             remoteFetch: {
                 self.remoteDataManager.deck(deckID, completion: $0)
-            },
-            remoteDependecies: { obj, depenedencyCompletion in
-                self.flashcards(obj.serverID) { _ in
-                    depenedencyCompletion()
-                }
             }, completion: completion)
     }
 

    // localFetch - blok powinien zwrócić dane z lokalnej bazy danych
    // remoteFetch - blok powinien zawołać przekazany blok z danymi z serwera
    // remoteParsing - blok przyjmuje dane typu, który przychodzi z serwera i powinien zwrócić dane typu lokalnego, np. JSON do Deck
    // remoteDependeciesCount - blok przyjmuje dane typu lokalnego i zwraca asynchronicznych zależności, które powinny zostać wywołane przed completion
    /* remoteDependecies - blok zawoła przekazany blok z danymi typu lokalnego i blokiem `dependencyCompletion`,
        który musi zostać wywołany tyle razy ile wartość zwrócona przez `remoteDependeciesCount`
    */
    // completion - ten blok jest wołany z obiektem typu lokalnego, np. Deck
    private func handleRequest<ServerResponseObject, DataManagerResponseObject>(
        localFetch localFetch: (() -> (DataManagerResponseObject?))? = nil,
                   remoteFetch: ((ServerResultType<ServerResponseObject>) -> ())->(),
                   remoteParsing: (obj: ServerResponseObject) -> (DataManagerResponseObject?),
                   remoteDependeciesCount: ((obj: DataManagerResponseObject) -> Int)? = nil,
                   remoteDependecies: ((obj: DataManagerResponseObject, dependencyCompletion: (() -> ())) -> ())? = nil,
                   completion: (DataManagerResponse<DataManagerResponseObject>) -> ()) {

        remoteFetch { response in
            switch response {
            case.Success(let object):
                if let parsedObject = remoteParsing(obj: object) {
                    let updateResult = self.updateInLocalDatabase(parsedObject)
                    if let remoteDependecies = remoteDependecies, var dependeciesCount = remoteDependeciesCount?(obj: parsedObject) where dependeciesCount > 0 {
                        let lock = NSLock()
                        remoteDependecies(obj: parsedObject) {
                            lock.lock()
                            dependeciesCount -= 1
                            if dependeciesCount < 1 {
                                completion(updateResult)
                            }
                            lock.unlock()
                        }
                        return
                    
                    } else {
                        completion(updateResult)
                    }
                    
                } else {
                    completion(.Error(obj: NewDataManagerError.JSONParseError))

        localFetch localFetch: (() -> [DataManagerResponseObject])? = nil,
                   remoteFetch: ((ServerResultType<[JSON]>) -> ()) -> (),
                   remoteParsing: (obj: [JSON]) -> [DataManagerResponseObject] = { DataManagerResponseObject.arrayWithJSONArray($0) },
                   completion: (DataManagerResponse<[DataManagerResponseObject]>) -> ()) {
        handleRequest(localFetch: localFetch, remoteFetch: remoteFetch, remoteParsing: remoteParsing, completion: completion)
    }

    //MARK: users
