public static IDisposable RequestAccess(object accessToken, EnumLicenseFeature srcFeature, EnumLicenseFeature requestedAccess)
{
var accessType = accessToken.GetType();
if (srcFeature != EnumLicenseFeature.Client || requestedAccess != EnumLicenseFeature.Text || accessToken == null)
{
throw new LicenseException(ErrorMessages.UnauthorizedAccessRequest).Trace();
}
if (accessType.Name == "AccessToken" && accessType.GetAssembly().ManifestModule.Name.StartsWith("<")) //Smart Assembly
{
return(new AccessToken(requestedAccess));
}
if (!_approved.__tokens.Contains(accessType.FullName))
{
var errorDetails = " __token: '{0}', Assembly: '{1}'".Fmt(
accessType.Name,
accessType.GetAssembly().ManifestModule.Name);
throw new LicenseException(ErrorMessages.UnauthorizedAccessRequest + errorDetails).Trace();
}
PclExport.Instance.VerifyInAssembly(accessType, _approved.__dlls);
return(new AccessToken(requestedAccess));
}
public static void ApprovedUsage(EnumLicenseFeature licenseFeature, EnumLicenseFeature requestedFeature,
int allowedUsage, int actualUsage, string message)
{
var hasFeature = (requestedFeature & licenseFeature) == requestedFeature;
if (hasFeature)
{
return;
}
if (actualUsage > allowedUsage)
{
throw new LicenseException(message.Fmt(allowedUsage)).Trace();
}
}
internal AccessToken(EnumLicenseFeature requested)
{
prevToken = AccessTokenScope;
AccessTokenScope = this;
tempFeatures = requested;
}
public static void AssertValidUsage(EnumLicenseFeature feature, EnumQuotaType quotaType, int count)
{
var licensedFeatures = ActivatedLicenseFeatures();
if ((EnumLicenseFeature.All & licensedFeatures) == EnumLicenseFeature.All) //Standard Usage
{
return;
}
if (AccessTokenScope != null)
{
if ((feature & AccessTokenScope.tempFeatures) == feature)
{
return;
}
}
//Free Quotas
switch (feature)
{
case EnumLicenseFeature.Text:
switch (quotaType)
{
case EnumQuotaType.Types:
ApprovedUsage(licensedFeatures, feature, FreeQuotas.TextTypes, count, ErrorMessages.ExceededTextTypes);
return;
}
break;
case EnumLicenseFeature.Redis:
switch (quotaType)
{
case EnumQuotaType.Types:
ApprovedUsage(licensedFeatures, feature, FreeQuotas.RedisTypes, count, ErrorMessages.ExceededRedisTypes);
return;
case EnumQuotaType.RequestsPerHour:
ApprovedUsage(licensedFeatures, feature, FreeQuotas.RedisRequestPerHour, count, ErrorMessages.ExceededRedisRequests);
return;
}
break;
case EnumLicenseFeature.OrmLite:
switch (quotaType)
{
case EnumQuotaType.Tables:
ApprovedUsage(licensedFeatures, feature, FreeQuotas.OrmLiteTables, count, ErrorMessages.ExceededOrmLiteTables);
return;
}
break;
case EnumLicenseFeature.ServiceStack:
switch (quotaType)
{
case EnumQuotaType.Operations:
ApprovedUsage(licensedFeatures, feature, FreeQuotas.ServiceStackOperations, count, ErrorMessages.ExceededServiceStackOperations);
return;
}
break;
case EnumLicenseFeature.Admin:
switch (quotaType)
{
case EnumQuotaType.PremiumFeature:
ApprovedUsage(licensedFeatures, feature, FreeQuotas.PremiumFeature, count, ErrorMessages.ExceededAdminUi);
return;
}
break;
case EnumLicenseFeature.Premium:
switch (quotaType)
{
case EnumQuotaType.PremiumFeature:
ApprovedUsage(licensedFeatures, feature, FreeQuotas.PremiumFeature, count, ErrorMessages.ExceededPremiumFeature);
return;
}
break;
}
throw new LicenseException("Unknown Quota Usage: {0}, {1}".Fmt(feature, quotaType)).Trace();
}
public static bool HasLicensedFeature(EnumLicenseFeature feature)
{
var licensedFeatures = ActivatedLicenseFeatures();
return((feature & licensedFeatures) == feature);
}
