| | | 1 | | using System.Linq.Expressions; |
| | | 2 | | using System.Globalization; |
| | | 3 | | using System.Text.Json; |
| | | 4 | | using OzonDomains; |
| | | 5 | | using OzonDomains.Models; |
| | | 6 | | using OzonDomains.Models.Partners; |
| | | 7 | | |
| | | 8 | | namespace Services.PartnerServices; |
| | | 9 | | |
| | | 10 | | /// <summary> |
| | | 11 | | /// Превращает правила партнёра в фильтр заказов. Правила объединяются через OR, условия внутри правила |
| | | 12 | | /// через AND, значения одного поля через OR. Нет активных правил — партнёр не видит ничего. Архивные заказы не видны ни |
| | | 13 | | /// </summary> |
| | | 14 | | public static class PartnerOrderScope |
| | | 15 | | { |
| | | 16 | | public static IQueryable<Order> Apply(IQueryable<Order> orders, IEnumerable<PartnerRule> rules) |
| | | 17 | | { |
| | 40 | 18 | | var predicate = BuildPredicate(rules); |
| | 44 | 19 | | if (predicate is null) return orders.Where(_ => false); |
| | | 20 | | |
| | | 21 | | // Архивные заказы скрыты от партнёров всегда: архив значит «убран из работы», как и в основном списке заказов. |
| | 36 | 22 | | return orders.Where(o => o.OrderArchive == null).Where(predicate); |
| | | 23 | | } |
| | | 24 | | |
| | | 25 | | public static Expression<Func<Order, bool>>? BuildPredicate(IEnumerable<PartnerRule> rules) |
| | | 26 | | { |
| | 40 | 27 | | var parameter = Expression.Parameter(typeof(Order), "o"); |
| | 40 | 28 | | Expression? any = null; |
| | | 29 | | |
| | 198 | 30 | | foreach (var rule in rules.Where(r => r.IsActive)) |
| | | 31 | | { |
| | 39 | 32 | | var ruleBody = BuildRuleBody(rule, parameter); |
| | | 33 | | // Правило, из которого не удалось построить ни одного условия, пропускаем: |
| | | 34 | | // оно бы открыло все заказы. Валидация сохранения такие правила не пропускает, это вторая линия защиты. |
| | 39 | 35 | | if (ruleBody is null) continue; |
| | 39 | 36 | | any = any is null ? ruleBody : Expression.OrElse(any, ruleBody); |
| | | 37 | | } |
| | | 38 | | |
| | 40 | 39 | | return any is null ? null : Expression.Lambda<Func<Order, bool>>(any, parameter); |
| | | 40 | | } |
| | | 41 | | |
| | | 42 | | private static Expression? BuildRuleBody(PartnerRule rule, ParameterExpression o) |
| | | 43 | | { |
| | 39 | 44 | | Expression? all = null; |
| | 158 | 45 | | foreach (var condition in rule.Conditions) |
| | | 46 | | { |
| | 40 | 47 | | var body = BuildCondition(condition, o); |
| | | 48 | | // Условие с непонятными значениями превращается в «ничего не подходит», а не в «подходит всё». |
| | 40 | 49 | | body ??= Expression.Constant(false); |
| | 40 | 50 | | all = all is null ? body : Expression.AndAlso(all, body); |
| | | 51 | | } |
| | | 52 | | |
| | 39 | 53 | | return all; |
| | | 54 | | } |
| | | 55 | | |
| | | 56 | | private static Expression? BuildCondition(PartnerRuleCondition condition, ParameterExpression o) |
| | | 57 | | { |
| | 40 | 58 | | var values = ParseValues(condition.ValuesJson); |
| | 40 | 59 | | switch (condition.Field) |
| | | 60 | | { |
| | | 61 | | case PartnerRuleField.Status: |
| | 1 | 62 | | return IntIn(o, nameof(Order.AppStatusId), values); |
| | | 63 | | case PartnerRuleField.Warehouse: |
| | 9 | 64 | | return IntIn(o, nameof(Order.ShipmentWarehouseId), values); |
| | | 65 | | case PartnerRuleField.Client: |
| | 1 | 66 | | return IntIn(o, nameof(Order.OzonClientId), values); |
| | | 67 | | case PartnerRuleField.Marketplace: |
| | | 68 | | { |
| | 1 | 69 | | var types = values |
| | 1 | 70 | | .Select(v => Enum.TryParse<ClientType>(v, true, out var t) ? (ClientType?)t : null) |
| | 3 | 71 | | .Where(t => t is not null).Select(t => t!.Value).Distinct().ToList(); |
| | 1 | 72 | | if (types.Count == 0) return null; |
| | 1 | 73 | | Expression<Func<Order, bool>> e = x => x.OzonClient != null && types.Contains(x.OzonClient.ClientType); |
| | 1 | 74 | | return Rebind(e, o); |
| | | 75 | | } |
| | | 76 | | case PartnerRuleField.DatePeriod: |
| | 14 | 77 | | return Period(values, o); |
| | | 78 | | case PartnerRuleField.Article: |
| | | 79 | | { |
| | 13 | 80 | | var articles = Upper(values); |
| | 13 | 81 | | if (articles.Count == 0) return null; |
| | | 82 | | // Владелец может ввести артикул и с кодом бренда (122RU19=HSH), и без него (122RU19). |
| | 13 | 83 | | Expression<Func<Order, bool>> e = x => |
| | 13 | 84 | | (x.Article != null && articles.Contains(x.Article.ToUpper())) || |
| | 13 | 85 | | (x.ProductKey != null && articles.Contains(x.ProductKey.ToUpper())); |
| | 13 | 86 | | return Rebind(e, o); |
| | | 87 | | } |
| | | 88 | | case PartnerRuleField.Brand: |
| | | 89 | | { |
| | 1 | 90 | | var brands = Upper(values); |
| | 1 | 91 | | if (brands.Count == 0) return null; |
| | 1 | 92 | | Expression<Func<Order, bool>> e = |
| | 1 | 93 | | x => x.Manufacturer != null && x.Manufacturer.Name != null && brands.Contains(x.Manufacturer.Name.To |
| | 1 | 94 | | return Rebind(e, o); |
| | | 95 | | } |
| | | 96 | | default: |
| | 0 | 97 | | return null; |
| | | 98 | | } |
| | | 99 | | } |
| | | 100 | | |
| | | 101 | | private static Expression? IntIn(ParameterExpression o, string property, List<string> values) |
| | | 102 | | { |
| | 11 | 103 | | var ids = values |
| | 12 | 104 | | .Select(v => int.TryParse(v, NumberStyles.Integer, CultureInfo.InvariantCulture, out var i) ? (int?)i : null |
| | 34 | 105 | | .Where(i => i is not null).Select(i => i!.Value).Distinct().ToList(); |
| | 12 | 106 | | if (ids.Count == 0) return null; |
| | | 107 | | |
| | 10 | 108 | | var member = Expression.Property(o, property); // int? |
| | 10 | 109 | | var hasValue = Expression.Property(member, nameof(Nullable<int>.HasValue)); |
| | 10 | 110 | | var value = Expression.Property(member, nameof(Nullable<int>.Value)); |
| | 10 | 111 | | var contains = Expression.Call( |
| | 10 | 112 | | typeof(Enumerable), nameof(Enumerable.Contains), [typeof(int)], |
| | 10 | 113 | | Expression.Constant(ids), value); |
| | 10 | 114 | | return Expression.AndAlso(hasValue, contains); |
| | | 115 | | } |
| | | 116 | | |
| | | 117 | | private static Expression? Period(List<string> values, ParameterExpression o) |
| | | 118 | | { |
| | 14 | 119 | | if (values.Count != 2) return null; |
| | 14 | 120 | | var from = ParseDate(values[0]); |
| | 14 | 121 | | var to = ParseDate(values[1]); |
| | 14 | 122 | | if (from is null && to is null) return null; |
| | | 123 | | |
| | 14 | 124 | | Expression<Func<Order, bool>> e = x => x.ProcessingDate != null; |
| | 14 | 125 | | Expression body = Rebind(e, o); |
| | 14 | 126 | | var date = Expression.Property(o, nameof(Order.ProcessingDate)); |
| | 14 | 127 | | if (from is { } f) |
| | 14 | 128 | | body = Expression.AndAlso(body, Expression.GreaterThanOrEqual(date, Expression.Constant((DateTime?)f, typeof |
| | 14 | 129 | | if (to is { } t) |
| | | 130 | | // «по» включает весь последний день. |
| | 1 | 131 | | body = Expression.AndAlso(body, Expression.LessThan(date, Expression.Constant((DateTime?)t.AddDays(1), typeo |
| | 14 | 132 | | return body; |
| | | 133 | | } |
| | | 134 | | |
| | | 135 | | private static DateTime? ParseDate(string value) => |
| | 28 | 136 | | DateTime.TryParseExact(value, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.None, out var d) ? d : |
| | | 137 | | |
| | | 138 | | private static List<string> Upper(List<string> values) => |
| | 52 | 139 | | values.Select(v => v.Trim().ToUpperInvariant()).Where(v => v.Length > 0).Distinct().ToList(); |
| | | 140 | | |
| | | 141 | | private static List<string> ParseValues(string json) |
| | | 142 | | { |
| | | 143 | | try |
| | | 144 | | { |
| | 100 | 145 | | return JsonSerializer.Deserialize<List<string>>(json)?.Select(v => (v ?? string.Empty).Trim()).ToList() ?? n |
| | | 146 | | } |
| | 0 | 147 | | catch (JsonException) |
| | | 148 | | { |
| | 0 | 149 | | return new(); |
| | | 150 | | } |
| | 40 | 151 | | } |
| | | 152 | | |
| | | 153 | | private static Expression Rebind(Expression<Func<Order, bool>> lambda, ParameterExpression target) => |
| | 29 | 154 | | new ParameterReplacer(lambda.Parameters[0], target).Visit(lambda.Body)!; |
| | | 155 | | |
| | 29 | 156 | | private sealed class ParameterReplacer(ParameterExpression from, ParameterExpression to) : ExpressionVisitor |
| | | 157 | | { |
| | 71 | 158 | | protected override Expression VisitParameter(ParameterExpression node) => node == from ? to : base.VisitParamete |
| | | 159 | | } |
| | | 160 | | } |