Delete the modules/operation-rate-limiting projects and their EF Core/application tests, remove InvalidateCacheAsync from the dynamic policy store, and update the error code namespace, localization keys and documentation to the framework-only layout.
Add LINGYUN.Abp.OperationRateLimiting.Abstractions for models, attributes, enums and constants, keep the interfaces in the core package, remove the Redis state accessor in favor of rule reset/release services, align the management rule records, and split the tests into core, EF Core, application and Redis projects.
Pick up the new profile recovery code endpoints and the renamed registration methods in the
account-generate-proxy.json snapshot, so the generated API description matches the
controllers again.
RegisterAsync was overloaded for the phone and the WeChat flow, so the client proxy and the
API description could not tell from the name which flow a call belonged to.
- rename RegisterAsync(PhoneRegisterDto) to PhoneRegisterAsync and
RegisterAsync(WeChatRegisterDto) to WeChatRegisterAsync in IAccountAppService,
AccountAppService and AccountController
- regenerate AccountClientProxy for the new names, the HTTP routes are unchanged
BREAKING CHANGE: the IAccountAppService.RegisterAsync overloads were renamed to
PhoneRegisterAsync and WeChatRegisterAsync. Consumers that call the application service or
the client proxy directly must update the call; the HTTP endpoints keep their routes.
A user could generate recovery codes once but never see how many were left or replace
them, so a lost or partly consumed code list could not be recovered.
- add AuthenticatorRecoveryCodeCountDto carrying the configured and the still available
number of codes
- add GetRecoveryCodeCountAsync and ResetRecoveryCodeAsync to IMyProfileAppService,
MyProfileAppService and MyProfileController, served as GET recovery-code-count and
PUT reset-recovery-code
- generate the codes with the configurable count instead of the hardcoded 10
- drop the redundant UserStore.ReplaceCodesAsync call, since
GenerateNewTwoFactorRecoveryCodesAsync already replaces the stored batch
- add the matching profile client proxy methods and localize the new messages
The number of two-factor recovery codes was hardcoded to 10 in the profile service and in
the two-factor page, so a deployment could not adjust it.
- replace the unused UseCaptcha constant, whose value pointed at ProhibitDefaultAdminRole
instead of a captcha setting, with GenerateRecoveryCodeNumber
- add the Security.GenerateRecoveryCodeNumber setting, defaulting to 10, for the default,
configuration, global and tenant value providers
- add IdentityTwoFactorBehaviourSettingHelper.GetGenerateRecoveryCodeNumber and use it from
the two-factor page instead of the literal
- localize the setting display name and description in en and zh-Hans
- Add the IBlobDownloadKeyGenerator abstraction, BlobDownloadKey and the default
HmacBlobDownloadKeyGenerator implementation
- Sign version, blob id, tenant id and expiration with HMAC-SHA256, verify with a
fixed-time comparison and accept canonical Base64Url encodings only
- Bucket the expiration by DownloadKeyWindow so the same key is generated within a
window and stays valid for at least DownloadKeyLifetime
- Add DownloadKeySecret/DownloadKeyLifetime/DownloadKeyWindow options, falling back to
the application encryption passphrase, and drop the global download key cache
- Remove the client-controlled TenantId from BlobDownloadByNameInput and drop the
download/by-name/t/{tenantId}/{name} route
- Do not switch the tenant from request data in BlobAppService; the policy check now
enforces the functional permission and the container/resource policy together
- Route id-based download, delete and download-url generation through the container
policy so resource grants of the users container cannot be bypassed
- Add a blob tenant ownership check and resolve storage of by-key downloads in the
tenant carried by the key
Keep the Elsa UserTask TagsJson column as text and convert the tags through a JSON value converter. This avoids Npgsql 10 mapping the collection to text[] while the Elsa migration still creates a text column.
The shared configureawait.props already supplies the ConfigureAwait weaver configuration for these assemblies, so the per-project FodyWeavers.xml/xsd files are redundant and no longer need to be tracked.
Move Quartz property binding into AbpQuartzSqlInstallerModule so the migrator and service use the same installer configuration. Align provider connection names, set the QRTZ_ table prefix, and quote the SQL Server database name when creating it.
Elsa 3.9 already maps UserTask TagsJson to text. Forcing the property to text[] made Npgsql fail when reading tags, so use the provider's default mapping instead.
Constrain MySQL index columns to fit utf8mb4 key limits, add the missing V3_8 bookmark-queue migration and dead-letter table, and normalize UserTasks indexed columns and long diagnostic fields.
Reference every Elsa Studio Blazor extension, register their ABP modules in DependsOn, add the UserTasks Studio module, and include the new module in the AllInOne solution.
Reduce the application base class to actor handling, move shared repository and record logic into each service, inject services through constructors, and map DTOs with Volo.Abp.Mapperly.
Register the approval flow, user tasks and identity services in AllInOne, expose the API route through the gateway, add the navigation entries and apply the merged approval database migrations.
Upgrade the workflow hosts and ElsaNext modules to Elsa 3, add the WorkflowService EF Core/DbMigrator projects, and align studio, localization and runtime configuration.
Apply the same split the OpenIddict grant already got to the legacy IdentityServer module, so
the OAuth login and the mini program login stop sharing a single validator, and drop the
removed AbpWeChatWorkGlobalConsts.GrantType constant that broke this project's build.
- WeChatWorkGrantValidator becomes abstract: GrantType becomes abstract and the user lookup
moves behind a FindUserInfoAsync hook; the constructor becomes protected
- add WeChatWorkOAuthGrantValidator (grant type wecom_oauth, user info exchange) and
WeChatWorkMiniProgramGrantValidator (grant type wecom_mp, code2session exchange mapped to
the user id plus the session key as user ticket)
- register both validators in AbpIdentityServerWeChatWorkModule
Fixes the CS0117 build error introduced when AbpWeChatWorkGlobalConsts.GrantType was renamed.
The QR code token grant trusted a client supplied tenant_id to switch the tenant context
before loading the user, so any caller could resolve a user id under an arbitrary tenant,
and the security events were logged under the generic login actions, which made a QR code
login indistinguishable from a password login in the audit trail.
- drop the tenant_id request parameter and use the tenant carried by the QR code itself
(QrCodeInfo.TenantId, taken from the scanning user's tenant)
- add QrCodeLoginSucceeded / QrCodeLoginFailed to IdentitySecurityLogExtendActionConsts and
use them from the QR code grant and the scan login page, including the failure log that was
missing when the user token does not match
- fix the invalid token branch, which logged LoginLockedout although the account was not
locked out; the real lockout branch keeps LoginLockedout
- update the README: correct grant_type=qr_code, document qrcode_key and drop the parameters
the flow no longer accepts (password, enterpriseId, the two factor and password change ones)
- register LINGYUN.Abp.OpenIddict.QrCode in the solution
BREAKING CHANGE: the QR code token request no longer accepts a tenant_id parameter; the tenant
is taken from the QR code. Clients that relied on passing tenant_id must drop it.
`NotificationChannelDataPropertyCache.GetProperties` is read for every payload on the
publish path (`NotificationChannelDataResolver` and `NotificationChannelDataSerializer`),
but it guarded the whole lookup with one process wide lock, so every cache hit queued
behind the lock and the first reflection plus `Expression.Compile()` for one payload type
blocked all the others. Types that have nothing to do with each other were serialized on
a single lock.
- replace the `Dictionary` plus `SyncLock` pair with a `ConcurrentDictionary<Type,
Lazy<NotificationChannelDataProperty[]>>`, so the hit path takes no lock and building
one type no longer blocks reads of another
- `Lazy<T>` keeps the build at most once: `GetOrAdd` may invoke its factory more than once
under contention, but only one instance is stored and returned, and
`LazyThreadSafetyMode.ExecutionAndPublication` makes the other threads wait for it
- move the reflection and the expression compiling behind the `Lazy` factory so they never
run while a lock is held
- extract the population into `CreateProperties`; the selector, the attribute driven key
resolution and the compiled getters/setters are unchanged, as is the returned array
(callers only enumerate it)
Tests: the cache had no concurrency coverage, which is the property this change rests on.
Add `Should_Build_Property_Metadata_Once_Under_Concurrency`, which reads five payload types
from 320 parallel calls and asserts every call observed the very same metadata instance, and
`Should_Return_Same_Instance_On_Repeated_Calls`.
Every channel needs its own message shape (a WeChat Work template card, a webhook news
article, a wx-pusher URL), but the only way to carry it was to stuff those types into
`NotificationData`, which couples the producer to the channels and forces a schema change
whenever a channel gains a field. Channels now declare their own payload types and the
property bag carries them under per channel key prefixes, so one `ExtraProperties` column
serves every channel and no notification table has to change.
- add the channel data contract to `LINGYUN.Abp.Notifications.Core`:
`NotificationChannelData` base type, `[NotificationChannelData]` /
`[NotificationChannelProperty]` annotations, `NotificationChannelDataDescriptor`,
`NotificationChannelDataFormat` and `NotificationChannelDataPresenceMode`
- add the implementation to `LINGYUN.Abp.Notifications`: `INotificationChannelDataResolver`
dispatching payloads in priority order, `INotificationChannelDataAccessor` reading and
writing typed values in the property bag, `INotificationChannelDataSerializer` for the
producer side, `INotificationChannelDataPresenceProvider`, `AbpNotificationChannelDataOptions`
and `AbpNotificationChannelDataConfigurationException` for registration time validation
- keys are namespaced per channel (`wx-work:`, `wx-work-hook:`, `wx-mp:`, `pusher:`, `plus:`)
and matched case insensitively, so channels cannot collide in the shared property bag;
complex payloads are stored as JSON strings and deserialized back with the configured
`IJsonSerializer`
- the WeChat Work channel gains 18 channel data types plus `WeChatWorkMessageFactory`, and
the webhook channel 16 plus `WeChatWorkWebhookMessageFactory`, covering text, markdown,
markdown_v2, image, news, file, voice, template card, mini program notice and mp news
- PushPlus, WxPusher and the WeChat mini program channel adopt the same contract; the mini
program keys are prefixed and the historical bare keys are kept as a read only fallback,
marked `[Obsolete]` with the provider's `ApplyLegacyKeys` as the only sanctioned read site
- delete the WxPusher `NotificationDataExtensions.SetUrl` in favour of the typed accessor
- add `WebhookTemplateCardSystemTextJsonConverter` so the abstract webhook template card
survives the property bag round trip, and make `WeChatWorkWebhookNewsMessage` public
- test projects `LINGYUN.Abp.Notifications.ChannelData.Tests`, `...PushPlus.Tests`,
`...WeChat.Work.Tests` and `...Webhook.WeChat.Work.Tests` (real ABP container, fake
senders registered through `context.Services.Replace` so no real API is called), the
mini program and wx-pusher tests now drive a fake sender, and each channel verifies
payloads restored from a raw database JSON string as well as from memory
The template card payload is written into the notification property bag as JSON and read
back when the notification is published, but TemplateCard is abstract, so Newtonsoft.Json
could never restore it ("Could not create an instance of type ... abstract class") and the
card was lost as soon as the notification was persisted or queued for a retry.
- add TemplateCardJsonConverter and TemplateCardSystemTextJsonConverter, which resolve the
concrete card from the card_type discriminator (read from the constructor IL, falling back
to the type name) and reject an unknown discriminator
- split NotificationDataWeChatWorkExtensions into partials per message type (file, mini
program, mp news, template card, text card, video, voice) and add the shared
TryGetMessagePayload helper that deserializes with the converter
- add the Safe, EnableIdTrans, EnableDuplicateCheck and DuplicateCheckInterval switches
- migrate TuiJuheNotificationPublishProvider to the NotificationPublishContext contract the
other providers already use, and skip the interceptors for notifications at or above Warn
- bind the WeChat Work mini program account through the new work-weixin/miniprogram/bind
endpoint using the code2session user id
- rename AbpNotificationOptions to AbpNotificationsPublishOptions in the tests, fix the SMS
test project reference, retarget the templating tests to net10.0, register the webhook
notification projects and add the missing IP2Region reference