asfsdfsdf

asdfsf.cs

public class Procedure 
{
}

public class EvaluatedUrlBuildRequirement 
{
    public Procedure EvaluatedOn { get; }
    public bool IsSatisfied { get; } 
    public Type RequirementType { get; }
    
    public EvaluatedUrlBuildRequirement(...) { }
}

public interface IUrlBuildRequirement 
{
    Task<IEnumerable<EvaluatedUrlBuildRequirement>> EvaluateAsync(IEnumerable<Procedure> procedures);
}

public class PublishedResultProtocolShouldExist : IUrlBuildRequirement 
{
    private readonly ITradingFacade _facade;
    
    public Task<EvaluatedUrlBuildRequirement> EvaluateAsync(Procedure procedure) 
    {
        var isProtocolExists = await _facade.IsPublishedResultProtocolExists(procedure.Id);
        return new EvaluatedUrlBuildRequirement(procedure, isProtocolExists, typeof(PublishedResultProtocolShouldExist).GetType());
    }
}

public interface IUrlBuildRequirementProvider {
    IEnumerable<IUrlBuildRequirement> GetRequirements(Procedure procedure);
}

public class UrlBuildRequirementProvider : IUrlBuildRequirementProvider {
    
    private readonly ITradingFacade _facade;
    
    public IEnumerable<IUrlBuildRequirement> GetRequirements(Procedure procedure) {
        if (procedureType == OK || procedureType == KOU) {
           yield return new PublishedResultProtocolShouldExist(_facade);
        }
        
        yield break;
    }
}

public async Task<ObjectList<CustomerProcedureShort>> GetProceduresAsync(CustomerProcedureSearchFilter filter) 
{
    [...]
    var items = proceduresDto.Items.Select(procedureDto => {
        var requirements = _urlBuildRequirementProvider.GetRequirements(procedureDto);
        var evaluatedRequirements = await Task.WhenAll(requirements.Select(r => r.EvaluateAsync(procedureDto)));
        
        procedure.Shortcuts = specificForProcedureUrlBuilder.GetCustomerProcedureShortcutUrls(procedure, 
           procedureDto.IsCurrentUserCanViewApplications, procedure.AcceptedApplicationCount, procedure.ConfirmedApplicationCount, evaluatedRequirements);
    });
}

        /// <inheritdoc />
        protected override void AddCustomShortcuts(ProcedureReference procedure, IList<ProcedureShortcut> navigationList,
            int? acceptedApplicationCount = null, int? confirmedApplicationCount = null, EvaluatedUrlBuildRequirement[] evaluatedRequirements)
        {

            if (StatesResultProtocolVisible.Contains(procedure.State.Id))
            {
                navigationList.Add(GetCustomerProcedureShortcut(procedure, ProcedureShortcutType.ResultProtocol));
            }

            
            var prococolPublishedRequirement = evaluatedRequirements.FirstOrDefault(r => r.RequirementType == typeof(PublishedResultProtocolShouldExist));
            if (prococolPublishedRequirement != null && prococolPublishedRequirement.IsSatisfied && procedure.State.Id == ProcedureState.NotTookPlace)
            {
                navigationList.Add(GetCustomerProcedureShortcut(procedure, ProcedureShortcutType.ResultProtocol));
            }
        }