         return progress
     }
 
+    private func notifyRefreshFinished() {
+        self.refreshObservers.forEach({ $0.refreshServiceDidFinishRefreshing() })
+    }
+
+    private func notifyRefreshStarted() {
+        refreshObservers.forEach({ $0.refreshServiceDidBeginRefreshing() })
+    }
+
+    private func deleteExistingEntities(imageIdentifiersToDelete: [String],
+                                        response: ModelCharacteristics,
+                                        transaction: DataStoreTransaction) {
+        imageIdentifiersToDelete.forEach(transaction.deleteImage)
+        response.events.deleted.forEach(transaction.deleteEvent)
+        response.tracks.deleted.forEach(transaction.deleteTrack)
+        response.rooms.deleted.forEach(transaction.deleteRoom)
+        response.conferenceDays.deleted.forEach(transaction.deleteConferenceDay)
+        response.maps.deleted.forEach(transaction.deleteMap)
+        response.dealers.deleted.forEach(transaction.deleteDealer)
+        response.knowledgeEntries.deleted.forEach(transaction.deleteKnowledgeEntry)
+        response.knowledgeGroups.deleted.forEach(transaction.deleteKnowledgeGroup)
+        response.announcements.deleted.forEach(transaction.deleteAnnouncement)
+    }
+
+    private func save(characteristics: ModelCharacteristics, in transaction: DataStoreTransaction) {
+        transaction.saveEvents(characteristics.events.changed)
+        transaction.saveRooms(characteristics.rooms.changed)
+        transaction.saveTracks(characteristics.tracks.changed)
+        transaction.saveConferenceDays(characteristics.conferenceDays.changed)
+        transaction.saveMaps(characteristics.maps.changed)
+        transaction.saveDealers(characteristics.dealers.changed)
+        transaction.saveKnowledgeGroups(characteristics.knowledgeGroups.changed)
+        transaction.saveKnowledgeEntries(characteristics.knowledgeEntries.changed)
+        transaction.saveAnnouncements(characteristics.announcements.changed)
+        transaction.saveLastRefreshDate(clock.currentDate)
+        transaction.saveImages(characteristics.images.changed)
+    }
+
 }

            guard let response = response else {
                finishLongRunningTask()

                self.refreshObservers.forEach({ $0.refreshServiceDidFinishRefreshing() })
                completionHandler(SyncError.failedToLoadResponse)
                return
            }

                self.eventBus.post(DomainEvent.LatestDataFetchedEvent(response: response))

                self.dataStore.performTransaction({ (transaction) in
                    self.deleteExistingEntities(imageIdentifiersToDelete: imageIdentifiersToDelete,
                                                response: response,
                                                transaction: transaction)

                    let isFullStoreRefresh: Bool = lastSyncTime == nil
                    if isFullStoreRefresh {
                        func not<T>(_ predicate: @escaping (T) -> Bool) -> (T) -> Bool {
                            return { (element) in return !predicate(element) }
                        }
