public AppContributorsController(ICommandBus commandBus, IAppPlansProvider appPlansProvider, IUserResolver userResolver)
: base(commandBus)
{
this.appPlansProvider = appPlansProvider;
this.userResolver = userResolver;
}
public AppApiFilter(IAppProvider appProvider, IAppPlansProvider appPlanProvider, IUsageTracker usageTracker)
{
this.appProvider = appProvider;
this.appPlanProvider = appPlanProvider;
this.usageTracker = usageTracker;
}
public static void CanChangePlan(ChangePlan command, IAppEntity app, IAppPlansProvider appPlans)
{
Guard.NotNull(command, nameof(command));
Validate.It(e =>
{
if (string.IsNullOrWhiteSpace(command.PlanId))
{
e(Not.Defined(nameof(command.PlanId)), nameof(command.PlanId));
return;
}
if (appPlans.GetPlan(command.PlanId) == null)
{
e(T.Get("apps.plans.notFound"), nameof(command.PlanId));
}
var plan = app.Plan;
if (!string.IsNullOrWhiteSpace(command.PlanId) && plan != null && !plan.Owner.Equals(command.Actor))
{
e(T.Get("apps.plans.notPlanOwner"));
}
});
}
public ApiCostsFilter(IAppLogStore appLogStore, IAppPlansProvider appPlansProvider, IClock clock, IUsageTracker usageTracker)
{
this.appLogStore = appLogStore;
this.appPlansProvider = appPlansProvider;
this.clock = clock;
this.usageTracker = usageTracker;
}
public static AppDto FromApp(IAppEntity app, string userId, bool isFrontend, IAppPlansProvider plans, Resources resources)
{
var permissions = GetPermissions(app, userId, isFrontend);
var result = SimpleMapper.Map(app, new AppDto());
result.Permissions = permissions.ToIds();
result.SetPlan(app, plans, resources, permissions);
result.SetImage(app, resources);
if (app.Contributors.TryGetValue(userId, out var roleName) && app.Roles.TryGet(app.Name, roleName, isFrontend, out var role))
{
result.RoleProperties = role.Properties;
}
else
{
result.RoleProperties = JsonValue.Object();
}
if (resources.Includes(P.ForApp(P.AppContents, app.Name), permissions))
{
result.CanAccessContent = true;
}
return(result.CreateLinks(resources, permissions));
}
public static void CanChangePlan(ChangePlan command, AppPlan plan, IAppPlansProvider appPlans)
{
Guard.NotNull(command, nameof(command));
Validate.It(() => "Cannot change plan.", e =>
{
if (string.IsNullOrWhiteSpace(command.PlanId))
{
e(Not.Defined("Plan id"), nameof(command.PlanId));
return;
}
if (appPlans.GetPlan(command.PlanId) == null)
{
e("A plan with this id does not exist.", nameof(command.PlanId));
}
if (!string.IsNullOrWhiteSpace(command.PlanId) && plan != null && !plan.Owner.Equals(command.Actor))
{
e("Plan can only changed from the user who configured the plan initially.");
}
if (string.Equals(command.PlanId, plan?.PlanId, StringComparison.OrdinalIgnoreCase))
{
e("App has already this plan.");
}
});
}
public static void CanChangePlan(ChangePlan command, AppPlan plan, IAppPlansProvider appPlans)
{
Guard.NotNull(command, nameof(command));
Validate.It(() => "Cannot change plan.", error =>
{
if (string.IsNullOrWhiteSpace(command.PlanId))
{
error(new ValidationError("PlanId is not defined.", nameof(command.PlanId)));
}
else if (appPlans.GetPlan(command.PlanId) == null)
{
error(new ValidationError("Plan id not available.", nameof(command.PlanId)));
}
if (!string.IsNullOrWhiteSpace(command.PlanId) && plan != null && !plan.Owner.Equals(command.Actor))
{
error(new ValidationError("Plan can only be changed from current user."));
}
if (string.Equals(command.PlanId, plan?.PlanId, StringComparison.OrdinalIgnoreCase))
{
error(new ValidationError("App has already this plan."));
}
});
}
public static AppDto FromApp(IAppEntity app, string userId, bool isFrontend, IAppPlansProvider plans, Resources resources)
{
var result = SimpleMapper.Map(app, new AppDto
{
PlanName = plans.GetPlanForApp(app).Plan.Name
});
var permissions = PermissionSet.Empty;
var isContributor = false;
if (app.Contributors.TryGetValue(userId, out var roleName) && app.Roles.TryGet(app.Name, roleName, isFrontend, out var role))
{
isContributor = true;
result.RoleProperties = role.Properties;
result.Permissions = permissions.ToIds();
permissions = role.Permissions;
}
if (resources.Includes(Shared.Permissions.ForApp(Shared.Permissions.AppContents, app.Name), permissions))
{
result.CanAccessContent = true;
}
if (resources.IsAllowed(Shared.Permissions.AppPlansChange, app.Name, additional: permissions))
{
result.PlanUpgrade = plans.GetPlanUpgradeForApp(app)?.Name;
}
return(result.CreateLinks(app, resources, permissions, isContributor));
}
public AppPlansController(ICommandBus commandBus,
IAppPlansProvider appPlansProvider,
IAppPlanBillingManager appPlansBillingManager)
: base(commandBus)
{
this.appPlansProvider = appPlansProvider;
this.appPlansBillingManager = appPlansBillingManager;
}
public AppsController(ICommandBus commandBus,
IAppProvider appProvider,
IAppPlansProvider appPlansProvider)
: base(commandBus)
{
this.appProvider = appProvider;
this.appPlansProvider = appPlansProvider;
}
public AppsController(ICommandBus commandBus,
IAppRepository appRepository,
IAppPlansProvider appPlansProvider)
: base(commandBus)
{
this.appRepository = appRepository;
this.appPlansProvider = appPlansProvider;
}
private void SetPlan(IAppEntity app, IAppPlansProvider plans, ApiController controller)
{
if (controller.HasPermission(AllPermissions.AppPlansChange, app.Name))
{
PlanUpgrade = plans.GetPlanUpgradeForApp(app)?.Name;
}
PlanName = plans.GetPlanForApp(app)?.Name;
}
private void SetPlan(IAppEntity app, IAppPlansProvider plans, Resources resources, PermissionSet permissions)
{
if (resources.IsAllowed(P.AppPlansChange, app.Name, additional: permissions))
{
PlanUpgrade = plans.GetPlanUpgradeForApp(app)?.Name;
}
PlanName = plans.GetPlanForApp(app).Plan.Name;
}
public ApiCostsFilter(IAppPlansProvider appPlansProvider, IApiUsageTracker usageTracker)
{
Guard.NotNull(appPlansProvider);
Guard.NotNull(usageTracker);
this.appPlansProvider = appPlansProvider;
this.usageTracker = usageTracker;
}
public UsageGate(IAppPlansProvider appPlansProvider, IApiUsageTracker apiUsageTracker, IGrainFactory grainFactory)
{
Guard.NotNull(apiUsageTracker, nameof(apiUsageTracker));
Guard.NotNull(appPlansProvider, nameof(appPlansProvider));
Guard.NotNull(grainFactory, nameof(grainFactory));
this.appPlansProvider = appPlansProvider;
this.apiUsageTracker = apiUsageTracker;
this.grainFactory = grainFactory;
}
public static AppDto FromApp(IAppEntity app, string subject, IAppPlansProvider plans)
{
var response = SimpleMapper.Map(app, new AppDto());
response.Permission = app.Contributors[subject];
response.PlanName = plans.GetPlanForApp(app)?.Name;
response.PlanUpgrade = plans.GetPlanUpgradeForApp(app)?.Name;
return(response);
}
public UsageGate(IAppPlansProvider appPlansProvider, IApiUsageTracker apiUsageTracker, IGrainFactory grainFactory)
{
Guard.NotNull(apiUsageTracker, nameof(apiUsageTracker));
Guard.NotNull(appPlansProvider, nameof(appPlansProvider));
Guard.NotNull(grainFactory, nameof(grainFactory));
this.appPlansProvider = appPlansProvider;
this.apiUsageTracker = apiUsageTracker;
usageLimitNotifier = grainFactory.GetGrain <IUsageNotifierGrain>(SingleGrain.Id);
}
public static ContributorsDto FromApp(IAppEntity app, IAppPlansProvider plans)
{
var plan = plans.GetPlanForApp(app);
var contributors = app.Contributors.Select(x => new ContributorDto {
ContributorId = x.Key, Permission = x.Value
}).ToArray();
return(new ContributorsDto {
Contributors = contributors, MaxContributors = plan.MaxContributors
});
}
public AppsController(ICommandBus commandBus,
IAssetStore assetStore,
IAssetThumbnailGenerator assetThumbnailGenerator,
IAppProvider appProvider,
IAppPlansProvider appPlansProvider)
: base(commandBus)
{
this.assetStore = assetStore;
this.assetThumbnailGenerator = assetThumbnailGenerator;
this.appProvider = appProvider;
this.appPlansProvider = appPlansProvider;
}
public AppDomainObject(IPersistenceFactory <State> persistence, ISemanticLog log,
InitialSettings initialPatterns,
IAppPlansProvider appPlansProvider,
IAppPlanBillingManager appPlansBillingManager,
IUserResolver userResolver)
: base(persistence, log)
{
this.userResolver = userResolver;
this.appPlansProvider = appPlansProvider;
this.appPlansBillingManager = appPlansBillingManager;
this.initialSettings = initialPatterns;
}
public UsagesController(
ICommandBus commandBus,
IUsageTracker usageTracker,
IAppPlansProvider appPlanProvider,
IAssetUsageTracker assetStatsRepository)
: base(commandBus)
{
this.usageTracker = usageTracker;
this.appPlanProvider = appPlanProvider;
this.assetStatsRepository = assetStatsRepository;
}
public static AppCreatedDto FromResult(EntityCreatedResult <Guid> result, IAppPlansProvider apps)
{
var response = new AppCreatedDto
{
Id = result.IdOrValue.ToString(),
Permission = AppContributorPermission.Owner,
PlanName = apps.GetPlan(null)?.Name,
PlanUpgrade = apps.GetPlanUpgrade(null)?.Name,
Version = result.Version
};
return(response);
}
public AssetsController(
ICommandBus commandBus,
IAssetQueryService assetQuery,
IAssetUsageTracker assetStatsRepository,
IAppPlansProvider appPlansProvider,
ITagService tagService)
: base(commandBus)
{
this.assetQuery = assetQuery;
this.assetStatsRepository = assetStatsRepository;
this.appPlansProvider = appPlansProvider;
this.tagService = tagService;
}
public AssetsController(
ICommandBus commandBus,
IAssetRepository assetRepository,
IAssetStatsRepository assetStatsRepository,
IAppPlansProvider appPlanProvider,
IOptions <AssetConfig> assetsConfig)
: base(commandBus)
{
this.assetsConfig = assetsConfig.Value;
this.assetRepository = assetRepository;
this.assetStatsRepository = assetStatsRepository;
this.appPlanProvider = appPlanProvider;
}
public ApiCostsFilter(IAppLogStore appLogStore, IAppPlansProvider appPlansProvider, IUsageTracker usageTracker, IClock clock)
{
Guard.NotNull(appLogStore);
Guard.NotNull(appPlansProvider);
Guard.NotNull(usageTracker);
Guard.NotNull(clock);
this.appLogStore = appLogStore;
this.appPlansProvider = appPlansProvider;
this.usageTracker = usageTracker;
this.clock = clock;
}
public static AppPlansDto FromDomain(IAppEntity app, IAppPlansProvider plans, bool hasPortal)
{
var(_, planId) = plans.GetPlanForApp(app);
var result = new AppPlansDto
{
CurrentPlanId = planId,
Plans = plans.GetAvailablePlans().Select(PlanDto.FromDomain).ToArray(),
PlanOwner = app.Plan?.Owner.Identifier,
HasPortal = hasPortal
};
return(result);
}
public static AppPlansDto FromApp(IAppEntity app, IAppPlansProvider plans, bool hasPortal)
{
var planId = app.Plan?.PlanId;
var response = new AppPlansDto
{
CurrentPlanId = planId,
Plans = plans.GetAvailablePlans().Select(PlanDto.FromPlan).ToArray(),
PlanOwner = app.Plan?.Owner.Identifier,
HasPortal = hasPortal
};
return(response);
}
public AssetsController(
ICommandBus commandBus,
IAssetQueryService assetQuery,
IAssetStatsRepository assetStatsRepository,
IAppPlansProvider appPlanProvider,
IOptions <AssetConfig> assetsConfig,
ITagService tagService)
: base(commandBus)
{
this.assetsConfig = assetsConfig.Value;
this.assetQuery = assetQuery;
this.assetStatsRepository = assetStatsRepository;
this.appPlanProvider = appPlanProvider;
this.tagService = tagService;
}
public AppDomainObject(IStore <DomainId> store, ISemanticLog log,
InitialPatterns initialPatterns,
IAppPlansProvider appPlansProvider,
IAppPlanBillingManager appPlansBillingManager,
IUserResolver userResolver)
: base(store, log)
{
Guard.NotNull(initialPatterns, nameof(initialPatterns));
Guard.NotNull(userResolver, nameof(userResolver));
Guard.NotNull(appPlansProvider, nameof(appPlansProvider));
Guard.NotNull(appPlansBillingManager, nameof(appPlansBillingManager));
this.userResolver = userResolver;
this.appPlansProvider = appPlansProvider;
this.appPlansBillingManager = appPlansBillingManager;
this.initialPatterns = initialPatterns;
}
public AssetsController(
ICommandBus commandBus,
IAssetQueryService assetQuery,
IAssetUsageTracker assetStatsRepository,
IAppPlansProvider appPlansProvider,
IOptions <AssetOptions> assetOptions,
IOptions <MyContentsControllerOptions> controllerOptions,
ITagService tagService)
: base(commandBus)
{
this.assetOptions = assetOptions.Value;
this.assetQuery = assetQuery;
this.assetStatsRepository = assetStatsRepository;
this.appPlansProvider = appPlansProvider;
this.controllerOptions = controllerOptions.Value;
this.tagService = tagService;
}
