Core data

let appDelegate = UIApplication.shared.delegate as! AppDelegate
// We need to create a context from this container.
let context = appDelegate.persistentContainer.viewContext
// Now let’s create an entity and new user records.
let entity = NSEntityDescription.entity(forEntityName: "Users", in: context)
let newUser = NSManagedObject(entity: entity!, insertInto: context)
// At last, we need to add some data to our newly created record for each keys using
newUser.setValue("Shashikant", forKey: "username")
newUser.setValue("1234", forKey: "password")
newUser.setValue("1", forKey: "age")
//Now we have set all the values. The next step is to save them inside the Core Data
//Save the Data
//The methods for saving the context already exist in the AppDelegate but we can explicitly add this code to save the context in the Database. Note that, we have to wrap this with do try and catch block.
do {          
   try context.save()       
  } catch {       
   print("Failed saving")
}

let request = NSFetchRequest<NSFetchRequestResult>(entityName: "Users")
// request.predicate = NSPredicate(format: "age = %@", "12")
request.returnsObjectsAsFaults = false // what does this do again? 🤔 
do {
   let result = try context.fetch(request)
   for data in result as! [NSManagedObject] {
      print(data.value(forKey: "username") as! String)
 }
} catch {
   print("Failed")
}

/**
 * ## Examples:
 * self.save(name: "Alex")
 */
func save(name: String) {
  guard let appDelegate = UIApplication.shared.delegate as? AppDelegate else { return }
  let managedContext = appDelegate.persistentContainer.viewContext // You can consider a managed object context as an in-memory “scratchpad” for working with managed objects.
  let entity = NSEntityDescription.entity(forEntityName: "Person", in: managedContext)!
  let person = NSManagedObject(entity: entity, insertInto: managedContext) //  first, you insert a new managed object into a managed object context;
  person.setValue(name, forKeyPath: "name") // You must spell the KVC key (name in this case) exactly as it appears in your Data Model, otherwise, your app will crash at runtime.
  do {
    try managedContext.save() //  you “commit” the changes in your managed object context to save it to disk.
    people.append(person)
  } catch let error as NSError {
    print("Could not save. \(error), \(error.userInfo)")
  }
}
func read() {
	guard let appDelegate = UIApplication.shared.delegate as? AppDelegate else { return }
	let managedContext = appDelegate.persistentContainer.viewContext // grab a reference to its persistent container to get your hands on its NSManagedObjectContext.
	let fetchRequest = NSFetchRequest<NSManagedObject>(entityName: "Person") // fetch all Person entities.
	do {
		var people: [NSManagedObject] = try managedContext.fetch(fetchRequest)
		people.forEach { person in let name = person.value(forKeyPath: "name"); print(name) } // Alex
	} catch let error as NSError {
		print("Could not fetch. \(error), \(error.userInfo)")
	}
}
/**
 * Update
 * ## Examples:
 * self.update(oldName: "Alex", newName: "Edward")
 */
func update(oldName: String, newName: String) {
	guard let appDelegate = UIApplication.shared.delegate as? AppDelegate else { return }
	let managedContext = appDelegate.persistentContainer.viewContext
	let fetchRequest = NSFetchRequest<NSManagedObject>(entityName: "Person") // fetch all
	do {
		var people: [NSManagedObject] = try managedContext.fetch(fetchRequest)
		guard let match: NSManagedObject = people.first(where: { $0.value(forKeyPath: "name") == oldName }) else { return }
		match.setValue(newName, forKeyPath: "name")
		try managedContext.save() //  you “commit” the changes in your managed object context to save it to disk.
      people.append(person)
	} catch let error as NSError {
		print("err. \(error), \(error.userInfo)")
	}
 }
/**
 * Delete
 * ## Examples:
 * self.delete(name: "James")
 */
func delete(name: String) {
	let appDel: AppDelegate = (UIApplication.sharedApplication().delegate as AppDelegate)
	let context = self.appDel.managedObjectContext!
	let fetchRequest = NSFetchRequest<NSManagedObject>(entityName: "Person") // fetch all
	guard let match: NSManagedObject = people.first(where: { $0.value(forKeyPath: "name") == name }) else { return }
	context.delete(match)
	do {
		try context.save()
	}
	catch {
		// Handle Error
	}
}

internal var _model: NSManagedObjectModel {
    let model = NSManagedObjectModel()

    // Create the entity
    let entity = NSEntityDescription()
    entity.name = "DTCachedFile"
    // Assume that there is a correct
    // `CachedFile` managed object class.
    entity.managedObjectClassName = String(CachedFile)

    // Create the attributes
    var properties = Array<NSAttributeDescription>()

    let remoteURLAttribute = NSAttributeDescription()
    remoteURLAttribute.name = "remoteURL"
    remoteURLAttribute.attributeType = .StringAttributeType
    remoteURLAttribute.optional = false
    remoteURLAttribute.indexed = true // what does this do again?
    properties.append(remoteURLAttribute)

    let fileDataAttribute = NSAttributeDescription()
    fileDataAttribute.name = "fileData"
    fileDataAttribute.attributeType = .BinaryDataAttributeType
    fileDataAttribute.optional = false
    fileDataAttribute.allowsExternalBinaryDataStorage = true // what does this do again?
    properties.append(fileDataAttribute)

    let lastAccessDateAttribute = NSAttributeDescription()
    lastAccessDateAttribute.name = "lastAccessDate"
    lastAccessDateAttribute.attributeType = .DateAttributeType
    lastAccessDateAttribute.optional = false
    properties.append(lastAccessDateAttribute)

    let expirationDateAttribute = NSAttributeDescription()
    expirationDateAttribute.name = "expirationDate"
    expirationDateAttribute.attributeType = .DateAttributeType
    expirationDateAttribute.optional = false
    properties.append(expirationDateAttribute)

    let contentTypeAttribute = NSAttributeDescription()
    contentTypeAttribute.name = "contentType"
    contentTypeAttribute.attributeType = .StringAttributeType
    contentTypeAttribute.optional = true
    properties.append(contentTypeAttribute)

    let fileSizeAttribute = NSAttributeDescription()
    fileSizeAttribute.name = "fileSize"
    fileSizeAttribute.attributeType = .Integer32AttributeType
    fileSizeAttribute.optional = false
    properties.append(fileSizeAttribute)

    let entityTagIdentifierAttribute = NSAttributeDescription()
    entityTagIdentifierAttribute.name = "entityTagIdentifier"
    entityTagIdentifierAttribute.attributeType = .StringAttributeType
    entityTagIdentifierAttribute.optional = true
    properties.append(entityTagIdentifierAttribute)

    // Add attributes to entity
    entity.properties = properties

    // Add entity to model
    model.entities = [entity]

    // Done :]
    return model
}

func lastUpdatedOn(_ persistentContainer: NSPersistentContainer) -> Date? {
    let coordinator = persistentContainer.persistentStoreCoordinator
    guard let store = coordinator.persistentStores.first else { fatalError("Unable to retrieve persistent store") }
    let metadata = coordinator.metadata(for: store)
    guard let lastUpdated: Date = metadata["lastUpdated"] as? Date else { return nil }
    return lastUpdated
}

let coordinator = persistentContainer.persistentStoreCoordinator
guard let store = coordinator.persistentStores.first else { fatalError("Unable to retrieve persistent store") }
coordinator.setMetadata(["lastUpdated": Date.now()], for: store)
let context = ...
context.save()