Ios 从其他两个核心数据对象创建复合对象

我有两个核心数据类患者和移交。一名患者可以进行多次切换

耐心。迅速

import Foundation
import CoreData

class Patient: NSManagedObject {

    @NSManaged var id: NSNumber
    @NSManaged var firstName: String
    @NSManaged var lastName: String
    @NSManaged var personalNumber: String
    @NSManaged var handovers: NSSet
}

import Foundation
import CoreData

class Handover: NSManagedObject {

    @NSManaged var date: NSDate
    @NSManaged var status: String
    @NSManaged var time: NSNumber
    @NSManaged var patient: Patient
}

移交。swift

import Foundation
import CoreData

class Patient: NSManagedObject {

    @NSManaged var id: NSNumber
    @NSManaged var firstName: String
    @NSManaged var lastName: String
    @NSManaged var personalNumber: String
    @NSManaged var handovers: NSSet
}

import Foundation
import CoreData

class Handover: NSManagedObject {

    @NSManaged var date: NSDate
    @NSManaged var status: String
    @NSManaged var time: NSNumber
    @NSManaged var patient: Patient
}

我需要显示在给定日期进行交接的患者列表。它需要按时间排序

下面是我得到的一个结果集示例

handovers = db.loadHandovers(NSDate.date())
for handover in handovers {
    let handover = handover as Handover
    println("\(handover.time) - \(handover.patient.firstName) \(handover.patient.lastName)")
}

请注意，患者Anna Andersson在8时有三次交接，患者Göte 2 Andersson在8时有四次交接。我需要根据患者对这些进行分组。但还有一个陷阱。如果同一患者在不同时间有更多的交接，则将其作为一个单独的组处理。例如，您可以看到Anna Andersson在14时进行了另一次移交。这需要是一个单独的组

+------+-------------------+-------------------+
| TIME |      PATIENT      |  NO. OF HANDOVERS |
+------+-------------------+-------------------+
|      |                   |                   |
| 08   |  Anna Andersson   |  3                |
|      |                   |                   |
| 08   |  Göte 2 Andersson |  4                |
|      |                   |                   |
| 10   |  Göte 2 Andersson |  1                |
|      |                   |                   |
| 11   |  Göte 2 Andersson |  1                |
|      |                   |                   |
| 14   |  Anna Andersson   |  1                |
+------+-------------------+-------------------+

我创建了一个名为

CompositeItem

的单独类来保存这些

import Foundation

public class CompositeItem {

    var patient: Patient!
    var handovers: [Handover] = []

    init() {

    }
}

我现在陷入困境的是如何迭代

切换

数组并将它们分组并创建复合对象

我有一个for循环，循环遍历检索到的切换

private var compositeItems: [CompositeItem] = []

handovers = db.loadHandovers(NSDate.date())

for handover in handovers {
    let handover = handover as Handover

    if compositeItems.isEmpty {
        let item = CompositeItem()
        item.patient = handover.patient
        item.handovers.append(handover)
    } else {
        // How can I check if the current Handover object has the same Patient and the time as the last added Handover.
        // And add it to the last `item`'s handovers array if they do match.
    }
}

我的问题是如何检查当前交接对象是否与上次添加的交接具有相同的患者和时间。并将其添加到最后一个

项

的切换数组（如果它们匹配）

我真的很感激任何帮助。这一部分让我感到困惑

---

谢谢。

您可以将合成项存储在字典中而不是数组中。dictionary键可以是patient对象的

NSManagedObjectID

，这样您就不会得到多个患者。因此，字典可能如下所示：

let patientsWithHandovers = Dictionary<NSManagedObjectID,CompositeItem>()

---

迭代数组并用对象填充字典的示例

let numbers = [1,3,2,4,5,6,11,13,12,15,8,21,22,31]  // array with even and odd numbers
var numberDict = Dictionary<String,[Int]>()  // dictionary for separating evens and odds

// initializing the dictionary
numberDict["even"] = []
numberDict["odd"] = []

for number in numbers {
    if number % 2 == 0 {
        numberDict["even"].append(number)
    }
    else {
        numberDict["odd"].append(number)
    }
}

let number=[1,3,2,4,5,6,11,13,12,15,8,21,22,31]//奇偶数数组
var numberDict=Dictionary（）//用于分隔偶数和赔率的字典
//初始化字典
numberDict[“偶数”]=[]
numberDict[“奇数”]=[]
数字中的数字{
如果数字%2==0{
numberDict[“偶数”]。追加（数字）
}
否则{
numberDict[“奇数”]。追加（数字）
}
}

现在，数字在字典中用两个键分开：偶数和奇数

---

我希望您能理解。

您可以使用

NSFetchRequest

为您进行分组。为此，您必须更改fetch以将其结果作为字典数组（

resultType=DictionaryResultType

）而不是对象数组返回。然后指定要分组的属性（

propertiesToGroupBy

）如患者姓名和时间，以及要包含在结果中的属性（

propertiesToFetch

），如患者姓名、时间、计数。尝试在loadHandovers功能中插入以下内容：

public func loadHandovers(date: NSDate) -> [AnyObject] {
    let fetchRequest = NSFetchRequest()
    let entityDescription = NSEntityDescription.entityForName("Handover", inManagedObjectContext: managedObjectContext!)
    let datePredicate = NSPredicate(format: "date > %@ AND date < %@", getStartDate(date), getEndDate(date))
    let descriptor = NSSortDescriptor(key: "time", ascending: true)

    let patientNameExp = NSExpression(forKeyPath:"patient.name")
    let patientNameED = NSExpressionDescription()

    patientNameED.expression = patientNameExp
    patientNameED.name = "patientName"
    patientNameED.expressionResultType = NSAttributeType.StringAttributeType

    let timeED : NSAttributeDescription = entityDescription?.attributesByName["time"] as NSAttributeDescription

    let countExp = NSExpression(format: "count:(name)")
    let countED = NSExpressionDescription()
    countED.name = "count"
    countED.expression = countExp
    countED.expressionResultType = NSAttributeType.Integer32AttributeType

    fetchRequest.resultType = NSFetchRequestResultType.DictionaryResultType
    fetchRequest.propertiesToFetch = [timeED, patientNameED, countED]
    fetchRequest.propertiesToGroupBy = [timeED, patientNameED]

    fetchRequest.entity = entityDescription
    fetchRequest.predicate = datePredicate
    fetchRequest.sortDescriptors = [descriptor]

    var error: NSError?
    let result = managedObjectContext?.executeFetchRequest(fetchRequest, error: &error)
    return result!
}

public func loadHandovers（日期：NSDate）->[AnyObject]{
让fetchRequest=NSFetchRequest（）
让entityDescription=NSEntityDescription.entityForName（“移交”，在managedObjectContext:managedObjectContext中！）
让datePredicate=NSPredicate（格式：“日期>%@和日期<%@”，getStartDate（日期），getEndDate（日期））
let descriptor=nssortddescriptor（键：“时间”，升序：true）
让patientNameExp=NSExpression（forKeyPath:“patient.name”）
让PatientNamed=NSExpressionDescription（）
patientNamed.expression=patientNameExp
patientNamed.name=“patientName”
PatientNamed.expressionResultType=NSAttributeType.StringAttributeType
将timeED:nsAttributedDescription=entityDescription？.attributesByName[“时间”]作为NSAttributedDescription
let countExp=NSExpression（格式：“count:（name）”）
let countED=NSExpressionDescription（）
countED.name=“count”
countED.expression=countExp
countED.expressionResultType=NSAttributeType.Integer32AttributeType
fetchRequest.resultType=NSFetchRequestResultType.DictionaryResultType
fetchRequest.propertiesToFetch=[timeED，patientNameED，countED]
fetchRequest.propertiesToGroupBy=[timeED，PatientNamed]
fetchRequest.entity=entityDescription
fetchRequest.predicate=datePredicate
fetchRequest.sortDescriptors=[描述符]
var错误：N错误？
让结果=managedObjectContext？.executeFetchRequest（fetchRequest，错误：&错误）
返回结果！
}

---

（抱歉我的快速语法，这表明我的操场没有错误，但可能需要选项排序等）。您应该返回一个数组，每个元素都是一个字典。字典将有“time”、“patientName”和“count”键，您可以使用这些键填充单元格。

事实上，我用我尝试过的旧方法解决了我的问题。下面是我写的代码

let handovers = db.loadHandovers(NSDate())

for handover in handovers {
    let handover = handover as Handover

    if compositeItems.isEmpty {
        let item = CompositeItem()
        item.patient = handover.patient
        item.handovers.append(handover)

        compositeItems.append(item)
    } else {
        let lastCompositeItem = compositeItems.last!
        let lastHandover = lastCompositeItem.handovers.last!

        if handover.patient.id == lastHandover.patient.id && handover.time == lastHandover.time {
            lastCompositeItem.handovers.append(handover)
        } else {
            let item = CompositeItem()
            item.patient = handover.patient
            item.handovers.append(handover)

            compositeItems.append(item)
        }
    }
}

---

你为什么要创建这个组合？这只是为了让你能够重现时间/患者/患者交接表吗？如果是这样的话，你可以通过一个精心设计的获取请求来实现它。当您点击一行时，用户将被导航到一个新屏幕，以显示所有切换的列表。是用于检索讲义的获取请求。我有一个建议，使用数据库为您进行分组。我将在一个单独的答案中对其进行概述，但我还没有使用Swift，所以必须让您自己编写代码。没问题。我可以试着把它转换成Swift。谢谢。嗨，谢谢你的回复。我有一个问题。您已经提到，使用patient对象的

NSManagedObjectID

可以防止重复的patient。但我需要多个病人，只是在不同的时间段。使用

NSManagedObjectID

会干扰这一点吗？或者我误解了什么？NSManagedObjectID是uniqe。我从你在上面的评论中提到的图像中看到，患者的ID不是正确的方法。您可能应该使用日期和时间的组合作为字典的键，然后为t存储所有患者