/** CalendarRollup -> Completeness **/
block (
    result = vector(string_type),
    foreach(master, __Parent__.Master.Activities, 
        actlevel = master.Proto.ActivityLevel,       
        result.add(
            catch(            
                Expr.attr("Completeness_" + Expr.ActivityRollupType.eval()).string().eval(),
                error
            )
        )
    )
)

/** CalendarRollup -> CompletionDate **/
block (
    result = vector(time_type),
    foreach(master, __Parent__.Master.Activities,
        actlevel = master.Proto.ActivityLevel,
        result.add(
            catch(                
                if ((d = Expr.attr("CompletionDate_" + Expr.ActivityRollupType.eval()).string().eval()).isNull(),
                    date(0),
                    d
                ),
                date(-1)
            )
        )        
    )
)

/** CalendarRollup -> ActivityRollupType**/
block (
    callevel = __Parent__.__Parent__.CalendarLevel,
    if (actlevel == callevel,
        if (master.Proto.ActivityType == enum("ACTIVITYTYPE","Milestone"),
            "Milestone",
            "Activity"
        ),
        if (callevel.AllChildren.contains(actlevel),
            "RollUp",    
            "No"
        )
    )
)

/** CalendarRollup -> Completeness_No **/
""

/** CalendarRollup -> CompletionDate_No **/
date(0)

/** CalendarRollup -> Completeness_RollUp **/
block (
    children = __Parent__.Children.filter((isNull(__Parent__.Active) || __Parent__.Active) && (__Parent__.CalendarLevel == actlevel || __Parent__.CalendarLevel.AllChildren.contains(actlevel))).join(CalendarRollup),
    complete = children.sum(if(CompletionDate.at(master.Index) > date(0), 1, 0)),
    total = children.size(),
    Expr.Completeness_Format.eval()
)

/** CalendarRollup -> CompletionDate_RollUp **/
block (
    children = __Parent__.Children.filter((isNull(__Parent__.Active) || __Parent__.Active) && (__Parent__.CalendarLevel == actlevel || __Parent__.CalendarLevel.AllChildren.contains(actlevel))).join(CalendarRollup),
    complete = children.sum(if(CompletionDate.at(master.Index) > date(0), 1, 0)),
    total = children.size(),
    if (complete==total,
        children.latest(CompletionDate.at(master.Index)),
        date(0)
    )		
)

/** CalendarRollup -> Completeness_Milestone **/
block (
	completed = CompletionDate,
	complete = master.Predecessors.sum(if(completed.at(Index)>date(0), 1, 0)),
	total = master.Predecessors.size(),	
	Expr.Completeness_Format.eval()
)

/** CalendarRollup -> CompletionDate_Milestone **/
block (	
	if (master.Predecessors.earliest(result.at(Index))>date(0),
		master.Predecessors.latest(result.at(Index)),
		date(0)
	)
)

/** CalendarRollup -> Completeness_Activity **/
block (
	res = __Parent__.Activities.filter(Master==master).first().Completeness,
	if (res.isNull(), "", res)
)

/** CalendarRollup -> CompletionDate_Activity **/
block (
	res = __Parent__.Activities.filter(Master==master).first().CompletionDate,
	if (res.isNull(), date(0), res)
)

/** CalendarRollup -> Completeness_Format **/
"" + complete + "/" + total + " " + if (total>0, integer(100*double(complete))/total, 0) + "%"

/** Calendar -> Predecessors **/
block (
    pred = Proto.Predecessors,   
    __Parent__.Activities.filter(pred.contains(Proto))
)
2
/** BaseActivity -> PastDue **/
if (CompletionDate>date(0), false, nowTime() > ExpectedEndDate) 


/** TrackingActivity -> TrackingItems **/
block (
    proto      = Master.Proto,
    tracking   = proto.TrackingType,
    level      = proto.Level,
    expression = Expr.attr("TrackingItems_" + tracking.attr("Node Name")),
    if(expression.isNull(), Expr.TrackingItems_Default, expression).eval()
)

/** TrackingActivity -> CompletenessHelper **/
block(
    proto      = Master.Proto,
    tracking   = proto.TrackingType,
    phase      = proto.TrackingPhase.attr("Node Name"),
    states     = Expr.attr("States_" + proto.TrackingState.enumValue()),
    timeAttrs  = Expr.attr("TimeAttr_" + proto.TrackingState.enumValue()),   
    complete   = 0,
    total      = 0,
    expression = Expr.attr("Completeness_" + tracking.attr("Node Name")),
    if(expression.isNull(), Expr.Completeness_Default, expression).eval()
)

/** TrackingActivity -> Completeness **/
block(
	Expr.CompletenessHelper.eval(),
	__Parent__.Expr.Completeness_Format.eval()
)

/** TrackingActivity -> CompletionDate **/
block(
	Expr.CompletenessHelper.eval(),
	if ((!proto.CompleteAll || complete == total) && complete > 0, latest, date(0))
)

/** TrackingActivity -> Completed **/
block(
	Expr.CompletenessHelper.eval(),
	complete
)

/** TrackingActivity -> Total **/
block(
	Expr.CompletenessHelper.eval(),
	total
)

/** TrackingActivity -> TrackingItems_Default **/
block(
    type = tracking.attr("Node Name"),
    subtype = proto.TrackingSubType,
    __Parent__.__Parent__.DataSheets.filter(attr("Node Type") == type && (subtype.enumValue() == "" || SubType == subtype))   
)

/** TrackingActivity -> Completeness_Default **/
block(
    revisions = if(phase.isNull(), TrackingItems.join(CurrentRevision), TrackingItems.join(PhaseCurrentRevisions[phase])),    
    complete = revisions.sum(if(states.contains(State), 1, 0)),
    total = revisions.size(),
    latest = revisions.latest(
        stateTime = date(0),
        foreach( timeAttr, timeAttrs,
            if (stateTime == date(0), stateTime = attr(timeAttr), stateTime)                                          
        )
    )
)

/** TrackingActivity -> TrackingItems_CollectionMatrix **/
__Parent__.__Parent__.Matrix

/** TrackingActivity -> TrackingItems_StyleColor **/
block (
	materials = Expr.TrackingItems_StyleMaterial.eval(),
	materials.join(Colors).filter(Styles.contains(style))
)

/** TrackingActivity -> Completeness_StyleColor **/
block(
    statesmanaged = Expr.attr("States_ColorMaterial_" + proto.TrackingState.enumValue()),
    managed = TrackingItems.filter(__Parent__.Material.Managed),
    unmanaged = TrackingItems.filter(!__Parent__.Material.Managed),
    complete = managed.sum(if(statesmanaged.contains(PhasedColor.Status), 1, 0)) +
               unmanaged.sum(if(states.contains(CurrentRevision.State), 1, 0)),
    total = TrackingItems.size(),
    latestmanaged = managed.latest(PhasedColor.StatusTime),
    latestunmanaged = unmanaged.latest(
        stateTime = date(0),
        foreach( timeAttr, timeAttrs,
            stateTime = if (stateTime == date(0), CurrentRevision.attr(timeAttr), stateTime)                                         
        )
    ),
    latest = latest(list(latestmanaged,latestunmanaged))
)

/** TrackingActivity -> TrackingItems_StyleMaterial **/	
block (
    phase = proto.TrackingPhase.attr("Node Name"),
    style = __Parent__.__Parent__,    
    materialschedule =  
        if ((parent = style.__Parent__).MaterialSchedule.isNull(), //Collection
            if ((parent = parent.__Parent__).MaterialSchedule.isNull(), //Category2
                if ((parent = parent.__Parent__).MaterialSchedule.isNull(), //Category1
                    parent.__Parent__.MaterialSchedule, //Season
                    parent.MaterialSchedule //Category1
                ),
                parent.MaterialSchedule //Category2                                        
            ),
            parent.MaterialSchedule //Collection
        ),
    materialschedule.BOM[phase].join(Suppliers).join(Materials).filter(Styles.contains(style) && ApprovalNeeded)
)

/** TrackingActivity -> Completeness_StyleMaterial **/
block(
    statesmanaged = Expr.attr("States_ColorMaterial_" + proto.TrackingState.enumValue()),
    managed = TrackingItems.filter(Material.Managed),
    unmanaged = TrackingItems.filter(!Material.Managed),
    complete = managed.sum(if(statesmanaged.contains(Material.Status), 1, 0)) +
               unmanaged.sum(if(states.contains(CurrentRevision.State), 1, 0)),
    total = TrackingItems.size(),

    latestmanaged = managed.latest(Material.StatusTime),
    latestunmanaged = unmanaged.latest(
        stateTime = date(0),
        foreach( timeAttr, timeAttrs,
            stateTime = if (stateTime == date(0), CurrentRevision.attr(timeAttr), stateTime)                                          
        )
    ),
    latest = latest(list(latestmanaged,latestunmanaged))
)

/** TrackingActivity -> TrackingItems_StyleMainMaterial **/	
block (
    phase = proto.TrackingPhase.attr("Node Name"),
    style = __Parent__.__Parent__,
    main = style.Attributes.BOMMainMaterials,  
    materialschedule =  
        if ((parent = style.__Parent__).MaterialSchedule.isNull(), //Collection
            if ((parent = parent.__Parent__).MaterialSchedule.isNull(), //Category2
                if ((parent = parent.__Parent__).MaterialSchedule.isNull(), //Category1
                    parent.__Parent__.MaterialSchedule, //Season
                    parent.MaterialSchedule //Category1
                ),
                parent.MaterialSchedule //Category2                                        
            ),
            parent.MaterialSchedule //Collection
        ),
    materialschedule.BOM[phase].join(Suppliers).join(Materials).filter(ApprovalNeeded && Styles.contains(style) && main.containes(Material))
)

/** TrackingActivity -> Completeness_StyleMainMaterial **/
Expr.Completeness_StyleMaterial.eval()

/** TrackingActivity -> States_APPROVED **/
Revision.State:APPROVED

/** TrackingActivity -> States_PENDING **/
Revision.State:PENDING
Revision.State:PENDING2
Revision.State:APPROVED

/** TrackingActivity -> States_ColorMaterial_APPROVED **/
ColorMaterialStatus:Approved

/** TrackingActivity -> States_ColorMaterial_PENDING **/
ColorMaterialStatus:Pending
ColorMaterialStatus:Approved


/** TrackingActivity -> TimeAttr_APPROVED **/
ApprovalTime

/** TrackingActivity -> TimeAttr_PENDING **/
PendingTime
Pending2Time
ApprovalTime

/** Milestone -> Completeness **/
__Parent__.CalendarRollup.Completeness[Master.Index]

/** Milestone -> CompletionDate **/
__Parent__.CalendarRollup.CompletionDate[Master.Index]