public async stt::Task GetRequestObjectAsync()
{
moq::Mock <UserLicenseService.UserLicenseServiceClient> mockGrpcClient = new moq::Mock <UserLicenseService.UserLicenseServiceClient>(moq::MockBehavior.Strict);
UserLicenseGetRequest request = new UserLicenseGetRequest
{
ApplicationId = "application_ideba4c06b",
UserId = "user_idd41a70e8",
};
UserLicense expectedResponse = new UserLicense
{
Kind = "kindf7aa39d9",
Enabled = true,
State = "state2e9ed39e",
#pragma warning disable CS0612
EditionId = "edition_idc7d1accf",
#pragma warning restore CS0612
CustomerId = "customer_id3b3724cb",
ApplicationId = "application_ideba4c06b",
Id = "id74b70bb8",
UserId = "user_idd41a70e8",
};
mockGrpcClient.Setup(x => x.GetAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <UserLicense>(stt::Task.FromResult(expectedResponse), null, null, null, null));
UserLicenseServiceClient client = new UserLicenseServiceClientImpl(mockGrpcClient.Object, null);
UserLicense responseCallSettings = await client.GetAsync(request, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
xunit::Assert.Same(expectedResponse, responseCallSettings);
UserLicense responseCancellationToken = await client.GetAsync(request, st::CancellationToken.None);
xunit::Assert.Same(expectedResponse, responseCancellationToken);
mockGrpcClient.VerifyAll();
}
public async Task <ProfileResponseModel> PostPremium(PremiumRequestModel model)
{
var user = await _userService.GetUserByPrincipalAsync(User);
if (user == null)
{
throw new UnauthorizedAccessException();
}
var valid = model.Validate(_globalSettings);
UserLicense license = null;
if (valid && _globalSettings.SelfHosted)
{
license = await ApiHelpers.ReadJsonFileFromBody <UserLicense>(HttpContext, model.License);
}
if (!valid || (_globalSettings.SelfHosted && license == null))
{
throw new BadRequestException("Invalid license.");
}
await _userService.SignUpPremiumAsync(user, model.PaymentToken,
model.AdditionalStorageGb.GetValueOrDefault(0), license);
return(new ProfileResponseModel(user, null));
}
public void GetRequestObject()
{
moq::Mock <UserLicenseService.UserLicenseServiceClient> mockGrpcClient = new moq::Mock <UserLicenseService.UserLicenseServiceClient>(moq::MockBehavior.Strict);
UserLicenseGetRequest request = new UserLicenseGetRequest
{
ApplicationId = "application_ideba4c06b",
UserId = "user_idd41a70e8",
};
UserLicense expectedResponse = new UserLicense
{
Kind = "kindf7aa39d9",
Enabled = true,
State = "state2e9ed39e",
#pragma warning disable CS0612
EditionId = "edition_idc7d1accf",
#pragma warning restore CS0612
CustomerId = "customer_id3b3724cb",
ApplicationId = "application_ideba4c06b",
Id = "id74b70bb8",
UserId = "user_idd41a70e8",
};
mockGrpcClient.Setup(x => x.Get(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
UserLicenseServiceClient client = new UserLicenseServiceClientImpl(mockGrpcClient.Object, null);
UserLicense response = client.Get(request);
xunit::Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
public void ApproveOrRejectLicense(List <UserLicenseRequest> licReqList)
{
List <UserLicenseRequest> licenseRequestList = new List <UserLicenseRequest>();
List <UserLicense> userLicenseList = new List <UserLicense>();
foreach (var licReq in licReqList)
{
var userlicReq = userLicenseRequestLogic.GetById(licReq.Id);
userlicReq.Comment = licReq.Comment;
userlicReq.ApprovedBy = licReq.ApprovedBy;
userlicReq.IsApproved = licReq.IsApproved;
userlicReq.IsRejected = licReq.IsRejected;
licenseRequestList.Add(userlicReq);
if (userlicReq.IsApproved)
{
UserLicense lic = new UserLicense();
lic.UserId = userlicReq.Requested_UserId;
lic.TeamId = userlicReq.TeamId;
lic.License = new LicenseData();
lic.License.ProductId = userlicReq.ProductId;
lic.License.UserSubscriptionId = userlicReq.UserSubscriptionId;
userLicenseList.Add(lic);
}
}
userLicenseRequestLogic.Update(licenseRequestList);
ErrorMessage = userLicenseRequestLogic.ErrorMessage;
if (userLicenseList.Count > 0 && String.IsNullOrEmpty(ErrorMessage))
{
licLogic.CreataeUserLicense(userLicenseList);
ErrorMessage = licLogic.ErrorMessage;
}
}
public async Task <PaymentResponseModel> PostPremium(PremiumRequestModel model)
{
var user = await _userService.GetUserByPrincipalAsync(User);
if (user == null)
{
throw new UnauthorizedAccessException();
}
var valid = model.Validate(_globalSettings);
UserLicense license = null;
if (valid && _globalSettings.SelfHosted)
{
license = await ApiHelpers.ReadJsonFileFromBody <UserLicense>(HttpContext, model.License);
}
if (!valid || (_globalSettings.SelfHosted && license == null))
{
throw new BadRequestException("Invalid license.");
}
var result = await _userService.SignUpPremiumAsync(user, model.PaymentToken,
model.PaymentMethodType.Value, model.AdditionalStorageGb.GetValueOrDefault(0), license);
var profile = new ProfileResponseModel(user, null, await _userService.TwoFactorIsEnabledAsync(user));
return(new PaymentResponseModel
{
UserProfile = profile,
PaymentIntentClientSecret = result.Item2,
Success = result.Item1
});
}
public async Task <ResponseModel> EditUserLicense(UserLicense userLicense, string token)
{
try
{
var responseClient = _httpClientFactory.CreateClient("AssetAPI");
responseClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
var result = await responseClient.PutAsJsonAsync <UserLicense>("api/UserLicense/" + userLicense.LicenseId, userLicense);
if (result.StatusCode != HttpStatusCode.OK)
{
var faliedResponse = await result.Content.ReadAsJsonAsync <RestException>();
return(new ResponseModel()
{
ResponseMessage = faliedResponse.Errors.ToString(),
ResponseCode = result.StatusCode.ToString()
});
}
return(new ResponseModel()
{
ResponseCode = result.StatusCode.ToString()
});
}
catch (Exception ex)
{
_logger.LogError($"Error encountered in UserLicenseService||EditUserLicense ErrorMessage: {ex.Message}");
throw ex;
}
}
public async Task UpdateLicenseAsync(User user, UserLicense license)
{
if (!_globalSettings.SelfHosted)
{
throw new InvalidOperationException("Licenses require self hosting.");
}
if (license == null || !_licenseService.VerifyLicense(license))
{
throw new BadRequestException("Invalid license.");
}
if (!license.CanUse(user))
{
throw new BadRequestException("This license is not valid for this user.");
}
var dir = $"{_globalSettings.LicenseDirectory}/user";
Directory.CreateDirectory(dir);
File.WriteAllText($"{dir}/{user.Id}.json", JsonConvert.SerializeObject(license, Formatting.Indented));
user.Premium = license.Premium;
user.RevisionDate = DateTime.UtcNow;
user.MaxStorageGb = _globalSettings.SelfHosted ? 10240 : license.MaxStorageGb; // 10 TB
user.LicenseKey = license.LicenseKey;
user.PremiumExpirationDate = license.Expires;
await SaveUserAsync(user);
}
static void Main()
{
UserLicense.Initialize();
ValidateUsingValidationEngine();
ValidateUsingValidationEngineAndExpando();
ValidateUsingProceduralEngine();
}
static void Main()
{
UserLicense.Initialize();
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new EmailForm());
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
UserLicense.Initialize(new MyLicense());
}
public BillingResponseModel(User user, UserLicense license)
: base("billing")
{
StorageName = user.Storage.HasValue ? Utilities.CoreHelpers.ReadableBytesSize(user.Storage.Value) : null;
StorageGb = user.Storage.HasValue ? Math.Round(user.Storage.Value / 1073741824D, 2) : 0; // 1 GB
MaxStorageGb = user.MaxStorageGb;
License = license;
Expiration = user.PremiumExpirationDate;
}
private bool CreateUserLicense(UserLicense lic)
{
var obj = AutoMapper.Mapper.Map <UserLicense, Core.Model.UserLicense>(lic);
obj = Work.UserLicenseRepository.Create(obj);
Work.UserLicenseRepository.Save();
LicenseLogic licLogic = new LicenseLogic();
licLogic.UpdateLicenseStatus(obj.LicenseId, true);
return(obj.Id > 0);
}
public SubscriptionResponseModel(User user, SubscriptionInfo subscription, UserLicense license)
: base("subscription")
{
Subscription = subscription.Subscription != null ? new BillingSubscription(subscription.Subscription) : null;
UpcomingInvoice = subscription.UpcomingInvoice != null ?
new BillingSubscriptionUpcomingInvoice(subscription.UpcomingInvoice) : null;
StorageName = user.Storage.HasValue ? Utilities.CoreHelpers.ReadableBytesSize(user.Storage.Value) : null;
StorageGb = user.Storage.HasValue ? Math.Round(user.Storage.Value / 1073741824D, 2) : 0; // 1 GB
MaxStorageGb = user.MaxStorageGb;
License = license;
Expiration = License.Expires;
}
public SubscriptionResponseModel(User user, UserLicense license = null)
: base("subscription")
{
StorageName = user.Storage.HasValue ? Utilities.CoreHelpers.ReadableBytesSize(user.Storage.Value) : null;
StorageGb = user.Storage.HasValue ? Math.Round(user.Storage.Value / 1073741824D, 2) : 0; // 1 GB
MaxStorageGb = user.MaxStorageGb;
Expiration = user.PremiumExpirationDate;
if (license != null)
{
License = license;
}
}
/// <summary>Snippet for Get</summary>
/// <remarks>
/// This snippet has been automatically generated for illustrative purposes only.
/// It may require modifications to work in your environment.
/// </remarks>
public void GetRequestObject()
{
// Create client
UserLicenseServiceClient userLicenseServiceClient = UserLicenseServiceClient.Create();
// Initialize request argument(s)
UserLicenseGetRequest request = new UserLicenseGetRequest
{
ApplicationId = "",
UserId = "",
};
// Make the request
UserLicense response = userLicenseServiceClient.Get(request);
}
public BillingResponseModel(User user, BillingInfo billing, UserLicense license)
: base("billing")
{
PaymentSource = billing.PaymentSource != null ? new BillingSource(billing.PaymentSource) : null;
Subscription = billing.Subscription != null ? new BillingSubscription(billing.Subscription) : null;
Charges = billing.Charges.Select(c => new BillingCharge(c));
UpcomingInvoice = billing.UpcomingInvoice != null ? new BillingInvoice(billing.UpcomingInvoice) : null;
StorageName = user.Storage.HasValue ? Utilities.CoreHelpers.ReadableBytesSize(user.Storage.Value) : null;
StorageGb = user.Storage.HasValue ? Math.Round(user.Storage.Value / 1073741824D, 2) : 0; // 1 GB
MaxStorageGb = user.MaxStorageGb;
License = license;
Expiration = License.Expires;
}
/// <summary>Snippet for GetAsync</summary>
/// <remarks>
/// This snippet has been automatically generated for illustrative purposes only.
/// It may require modifications to work in your environment.
/// </remarks>
public async Task GetRequestObjectAsync()
{
// Create client
UserLicenseServiceClient userLicenseServiceClient = await UserLicenseServiceClient.CreateAsync();
// Initialize request argument(s)
UserLicenseGetRequest request = new UserLicenseGetRequest
{
ApplicationId = "",
UserId = "",
};
// Make the request
UserLicense response = await userLicenseServiceClient.GetAsync(request);
}
public BillingResponseModel(User user, BillingInfo billing, UserLicense license)
: base("billing")
{
CreditAmount = billing.CreditAmount;
PaymentSource = billing.PaymentSource != null ? new BillingSource(billing.PaymentSource) : null;
Subscription = billing.Subscription != null ? new BillingSubscription(billing.Subscription) : null;
Transactions = billing.Transactions?.Select(t => new BillingTransaction(t));
Invoices = billing.Invoices?.Select(i => new BillingInvoice(i));
UpcomingInvoice = billing.UpcomingInvoice != null ? new BillingInvoiceInfo(billing.UpcomingInvoice) : null;
StorageName = user.Storage.HasValue ? Utilities.CoreHelpers.ReadableBytesSize(user.Storage.Value) : null;
StorageGb = user.Storage.HasValue ? Math.Round(user.Storage.Value / 1073741824D, 2) : 0; // 1 GB
MaxStorageGb = user.MaxStorageGb;
License = license;
Expiration = License.Expires;
}
/// <summary>Snippet for GetAsync</summary>
public async Task GetRequestObjectAsync()
{
// Snippet: GetAsync(UserLicenseGetRequest, CallSettings)
// Additional: GetAsync(UserLicenseGetRequest, CancellationToken)
// Create client
UserLicenseServiceClient userLicenseServiceClient = await UserLicenseServiceClient.CreateAsync();
// Initialize request argument(s)
UserLicenseGetRequest request = new UserLicenseGetRequest
{
ApplicationId = "",
UserId = "",
};
// Make the request
UserLicense response = await userLicenseServiceClient.GetAsync(request);
// End snippet
}
/// <summary>
/// creating the UserLicense this can be used to update the single user.
/// </summary>
/// <param name="licList"></param>
/// <returns></returns>
public bool CreataeUserLicense(List <UserLicense> licList)
{
LicenseLogic licLogic = new LicenseLogic();
foreach (var lic in licList)
{
var userLicList = Work.UserLicenseRepository.GetData(ul => ul.UserId == lic.UserId).ToList();
var data = Work.LicenseDataRepository.GetData(l => l.ProductId == lic.License.ProductId && l.UserSubscriptionId == lic.License.UserSubscriptionId).ToList().Select(l => l.Id);
var obj = userLicList.FirstOrDefault(ul => data.Contains(ul.LicenseId));
if (obj == null)
{
var licId = licLogic.GetUnassignedLicense(lic.License.UserSubscriptionId, lic.License.ProductId).Id;
UserLicense ul = new UserLicense();
ul.UserId = lic.UserId;
ul.LicenseId = licId;
ul.TeamId = lic.TeamId;
CreateUserLicense(ul);
}
userLicList.Remove(obj);
}
return(true);
}
public async Task UpdateLicenseAsync_Success(SutProvider <UserService> sutProvider,
User user, UserLicense userLicense)
{
using var tempDir = new TempDirectory();
var now = DateTime.UtcNow;
userLicense.Issued = now.AddDays(-10);
userLicense.Expires = now.AddDays(10);
userLicense.Version = 1;
userLicense.Premium = true;
user.EmailVerified = true;
user.Email = userLicense.Email;
sutProvider.GetDependency <Settings.IGlobalSettings>().SelfHosted = true;
sutProvider.GetDependency <Settings.IGlobalSettings>().LicenseDirectory = tempDir.Directory;
sutProvider.GetDependency <ILicensingService>()
.VerifyLicense(userLicense)
.Returns(true);
await sutProvider.Sut.UpdateLicenseAsync(user, userLicense);
var filePath = Path.Combine(tempDir.Directory, "user", $"{user.Id}.json");
Assert.True(File.Exists(filePath));
var document = JsonDocument.Parse(File.OpenRead(filePath));
var root = document.RootElement;
Assert.Equal(JsonValueKind.Object, root.ValueKind);
// Sort of a lazy way to test that it is indented but not sure of a better way
Assert.Contains('\n', root.GetRawText());
AssertHelper.AssertJsonProperty(root, "LicenseKey", JsonValueKind.String);
AssertHelper.AssertJsonProperty(root, "Id", JsonValueKind.String);
AssertHelper.AssertJsonProperty(root, "Premium", JsonValueKind.True);
var versionProp = AssertHelper.AssertJsonProperty(root, "Version", JsonValueKind.Number);
Assert.Equal(1, versionProp.GetInt32());
}
public void CreateUserLicense()
{
try
{
List <UserLicense> userLicList = new List <UserLicense>();
UserLicense lic = new UserLicense();
lic.UserId = TeamMember.UserId;
lic.LicenseId = LicenseList[0].Id;
lic.License = licLogic.GetLicenseById(lic.LicenseId);
userLicList.Add(lic);
UserLicense lic1 = new UserLicense();
lic1.UserId = TeamMember.UserId;
lic1.LicenseId = LicenseList[1].Id;
lic1.License = licLogic.GetLicenseById(lic1.LicenseId);
userLicList.Add(lic1);
userLicLogic.CreateMultiUserLicense(userLicList, new List <string>()
{
TeamMember.UserId
});
userLicList = new List <UserLicense>();
UserLicense lic2 = new UserLicense();
lic2.UserId = AdminUser.UserId;
lic2.LicenseId = LicenseList[2].Id;
lic2.License = licLogic.GetLicenseById(lic2.LicenseId);
userLicList.Add(lic2);
userLicLogic.CreateMultiUserLicense(userLicList, new List <string>()
{
AdminUser.UserId
});
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
}
static void Main()
{
UserLicense.Initialize();
ValidatePersonIdentity_StructuredRoutine();
}
public override void Initialize(Dictionary <string, Dictionary <string, GameObject> > preloadedObjects)
{
instance = this;
//new Test();
//return;
#region VerifyVersion
Logger.Log("Load Global Json");
ItemSettings global = SerializeHelper.LoadGlobalSettings <ItemSettings>();
if (global != null)
{
if (global.mod_version > Version)
{
new ErrorPanel($"Require Version:{global.mod_version},BUT you Version:{Version}\n(你的MOD版本该更新了)");
throw new FileLoadException("Try To Load an newer json data in an older mod,please update mod");
}
ItemData = global;
Logger.Log("Loaded Json");
}
#endregion
#region Init GameObject
ObjectLoader.Load(preloadedObjects);
BehaviourProcessor.RegisterBehaviour <Particle>();
BehaviourProcessor.RegisterBehaviour <Draw>();
BehaviourProcessor.RegisterBehaviour <OtherBehaviour>();
BehaviourProcessor.RegisterBehaviour <AreaBehaviour>();
BehaviourProcessor.RegisterBehaviour <MovablePlatform>();
BehaviourProcessor.RegisterBehaviour <ModifyGameItem>();
BehaviourProcessor.RegisterBehaviour <Mana>();
BehaviourProcessor.RegisterBehaviour <AudioBehaviours>();
BehaviourProcessor.RegisterBehaviour <OneShotBehaviour>();
BehaviourProcessor.RegisterBehaviour <Scope>();
BehaviourProcessor.RegisterBehaviour <Bench>();
BehaviourProcessor.RegisterSharedBehaviour <DefaultBehaviour>();
BehaviourProcessor.RegisterSharedBehaviour <UnVisableBehaviour>();
BehaviourProcessor.RegisterSharedBehaviour <DelayResizableBehaviour>();
#endregion
#region InitGUI
UIObj = new GameObject();
UIObj.AddComponent <GUIController>();
UnityEngine.Object.DontDestroyOnLoad(UIObj);
GUIController.Instance.BuildMenus();
#endregion
#region SetupCallBack
SelectGetter = GetKeyPress;
SelectGetter += PickPanel.SelectFocus;
UnityEngine.SceneManagement.SceneManager.sceneLoaded += SpawnFromSettings;
UnityEngine.SceneManagement.SceneManager.sceneLoaded += ShowRespawn;
UnityEngine.SceneManagement.SceneManager.sceneLoaded += AutoSaveModification;
On.GameManager.PositionHeroAtSceneEntrance += HeroOutBoundSave;
ModHooks.Instance.LanguageGetHook += DLanguage.MyLanguage;
ModHooks.Instance.ApplicationQuitHook += SaveJson;
if (Settings.CreateMode)
{
ModHooks.Instance.HeroUpdateHook += OperateItem;
}
#endregion
UserLicense.ShowLicense();
}
public IActionResult UpdateUserLicense(UserLicense userLicense)
{
userLicense.userId = this.User.GetUserId();
_uLicenseRepo.UpdateUserLicense(userLicense);
return(Ok());
}
public async Task SignUpPremiumAsync(User user, string paymentToken, PaymentMethodType paymentMethodType,
short additionalStorageGb, UserLicense license)
{
if (user.Premium)
{
throw new BadRequestException("Already a premium user.");
}
if (additionalStorageGb < 0)
{
throw new BadRequestException("You can't subtract storage!");
}
IPaymentService paymentService = null;
if (_globalSettings.SelfHosted)
{
if (license == null || !_licenseService.VerifyLicense(license))
{
throw new BadRequestException("Invalid license.");
}
if (!license.CanUse(user))
{
throw new BadRequestException("This license is not valid for this user.");
}
var dir = $"{_globalSettings.LicenseDirectory}/user";
Directory.CreateDirectory(dir);
File.WriteAllText($"{dir}/{user.Id}.json", JsonConvert.SerializeObject(license, Formatting.Indented));
}
else
{
await _paymentService.PurchasePremiumAsync(user, paymentMethodType, paymentToken, additionalStorageGb);
}
user.Premium = true;
user.RevisionDate = DateTime.UtcNow;
if (_globalSettings.SelfHosted)
{
user.MaxStorageGb = 10240; // 10 TB
user.LicenseKey = license.LicenseKey;
user.PremiumExpirationDate = license.Expires;
}
else
{
user.MaxStorageGb = (short)(1 + additionalStorageGb);
user.LicenseKey = CoreHelpers.SecureRandomString(20);
}
try
{
await SaveUserAsync(user);
await _pushService.PushSyncVaultAsync(user.Id);
}
catch when(!_globalSettings.SelfHosted)
{
await paymentService.CancelAndRecoverChargesAsync(user);
throw;
}
}
public async Task SignUpPremiumAsync(User user, string paymentToken, short additionalStorageGb, UserLicense license)
{
if (user.Premium)
{
throw new BadRequestException("Already a premium user.");
}
IPaymentService paymentService = null;
if (_globalSettings.SelfHosted)
{
if (license == null || !_licenseService.VerifyLicense(license))
{
throw new BadRequestException("Invalid license.");
}
if (!license.CanUse(user))
{
throw new BadRequestException("This license is not valid for this user.");
}
var dir = $"{_globalSettings.LicenseDirectory}/user";
Directory.CreateDirectory(dir);
File.WriteAllText($"{dir}/{user.Id}.json", JsonConvert.SerializeObject(license, Formatting.Indented));
}
else if (!string.IsNullOrWhiteSpace(paymentToken))
{
if (paymentToken.StartsWith("btok_"))
{
throw new BadRequestException("Invalid token.");
}
if (paymentToken.StartsWith("tok_"))
{
paymentService = new StripePaymentService();
}
else
{
paymentService = new BraintreePaymentService(_globalSettings);
}
await paymentService.PurchasePremiumAsync(user, paymentToken, additionalStorageGb);
}
else
{
throw new InvalidOperationException("License or payment token is required.");
}
user.Premium = true;
user.RevisionDate = DateTime.UtcNow;
if (_globalSettings.SelfHosted)
{
user.MaxStorageGb = 10240; // 10 TB
user.LicenseKey = license.LicenseKey;
user.PremiumExpirationDate = license.Expires;
}
else
{
user.MaxStorageGb = (short)(1 + additionalStorageGb);
user.LicenseKey = CoreHelpers.SecureRandomString(20);
}
try
{
await SaveUserAsync(user);
}
catch when(!_globalSettings.SelfHosted)
{
await paymentService.CancelAndRecoverChargesAsync(user);
throw;
}
}
public async Task <User> AssignAsync(string userId, UserLicense UserLicense)
{
return(await _call.PostAsync <User, UserLicense>($"users/{userId}/assignLicense", UserLicense).ConfigureAwait(false));
}
public async Task <Tuple <bool, string> > SignUpPremiumAsync(User user, string paymentToken,
PaymentMethodType paymentMethodType, short additionalStorageGb, UserLicense license,
TaxInfo taxInfo)
{
if (user.Premium)
{
throw new BadRequestException("Already a premium user.");
}
if (additionalStorageGb < 0)
{
throw new BadRequestException("You can't subtract storage!");
}
if ((paymentMethodType == PaymentMethodType.GoogleInApp ||
paymentMethodType == PaymentMethodType.AppleInApp) && additionalStorageGb > 0)
{
throw new BadRequestException("You cannot add storage with this payment method.");
}
string paymentIntentClientSecret = null;
IPaymentService paymentService = null;
if (_globalSettings.SelfHosted)
{
if (license == null || !_licenseService.VerifyLicense(license))
{
throw new BadRequestException("Invalid license.");
}
if (!license.CanUse(user))
{
throw new BadRequestException("This license is not valid for this user.");
}
var dir = $"{_globalSettings.LicenseDirectory}/user";
Directory.CreateDirectory(dir);
File.WriteAllText($"{dir}/{user.Id}.json", JsonConvert.SerializeObject(license, Formatting.Indented));
}
else
{
paymentIntentClientSecret = await _paymentService.PurchasePremiumAsync(user, paymentMethodType,
paymentToken, additionalStorageGb, taxInfo);
}
user.Premium = true;
user.RevisionDate = DateTime.UtcNow;
if (_globalSettings.SelfHosted)
{
user.MaxStorageGb = 10240; // 10 TB
user.LicenseKey = license.LicenseKey;
user.PremiumExpirationDate = license.Expires;
}
else
{
user.MaxStorageGb = (short)(1 + additionalStorageGb);
user.LicenseKey = CoreHelpers.SecureRandomString(20);
}
try
{
await SaveUserAsync(user);
await _pushService.PushSyncVaultAsync(user.Id);
await _referenceEventService.RaiseEventAsync(
new ReferenceEvent(ReferenceEventType.UpgradePlan, user)
{
Storage = user.MaxStorageGb,
PlanName = PremiumPlanId,
});
}
catch when(!_globalSettings.SelfHosted)
{
await paymentService.CancelAndRecoverChargesAsync(user);
throw;
}
return(new Tuple <bool, string>(string.IsNullOrWhiteSpace(paymentIntentClientSecret),
paymentIntentClientSecret));
}
/// <summary>
/// Assign office license to specific user
/// </summary>
/// <param name="userId"></param>
/// <param name="UserLicense"></param>
/// <returns></returns>
public async Task <User> AssignAsync(string userId, UserLicense UserLicense)
{
return(await _officeLincenseManager.AssignAsync(userId, UserLicense).ConfigureAwait(false));
}
