public async Task UpdateAsyncShould_ReturnsTrue_IfManagerForAllRegionsUpdatesIssue_WithPictureFile() { //Arrange var pictureService = IPictureServiceMock.New(DefaultImageId); var activityService = new Mock <IManagerActivityService>(); var service = new ManagerIssueService( Db, pictureService.Object, activityService.Object); var manager = UserCreator.Create(RegionType.All); await Db.AddAsync(manager); var issue = UrbanIssueCreator.CreateIssue(RegionType.Western); await Db.AddAsync(issue); await Db.SaveChangesAsync(); var pictureFile = new Mock <IFormFile>(); //Act var result = await service.UpdateAsync( manager, issue.Id, null, null, issue.Region, IssueType.DamagedRoads, null, pictureFile : pictureFile.Object); //Assert result.Should().BeTrue(); pictureService.Verify(p => p.UploadImageAsync(It.IsAny <string>(), It.IsAny <IFormFile>()), Times.Once); pictureService.Verify(p => p.DeleteImageAsync(It.IsAny <int>()), Times.Once); activityService.Verify(a => a.WriteLogAsync(It.IsAny <string>(), It.IsAny <ManagerActivityType>()), Times.Once); }
/// <exception cref="Bad"> /// <see cref="Bad.AccessError"/> if sender if not client/respondent/admin. /// </exception> /// <exception cref="Bad"> /// <see cref="Bad.UselessRequest"/> if appeal is resolved. /// </exception> /// <exception cref="Bad"> /// <see cref="Bad.UnknownError"/>. /// </exception> public async Task <AppealMessage> HandleAsync(CreateAppealMessageData data) { _data = data.Validate(); await _data.Sender.LoadRoleSetAsync(_userManager); CheckAccess(); CheckAppeal(); _data.EnsureNoErrors(); var newMessage = new AppealMessage { Appeal = _data.Appeal, Sender = _data.Sender, Content = _data.Content, }; try { await Db.AddAsync(newMessage); await Db.SaveChangesAsync(); } catch (Exception ex) { Logger.LogError(ex, "Cannot create new AppealMessage!"); throw Bad.UnknownError; } OnCreated?.Invoke(newMessage); return(newMessage); }
/// <exception cref="Bad"> /// <see cref="Bad.AccessError"/>. /// </exception> /// <exception cref="Bad"> /// <see cref="Bad.DataError"/>. /// </exception> /// <exception cref="Bad"> /// <see cref="Bad.UnknownError"/>. /// </exception> public async Task <Topic> CreateAsync(CreateTopicData data, AppUser creator) { _data = data.Validate(); _data.EnsureNoErrors(); _creator = creator; await _creator.LoadRoleSetAsync(Db); CheckAccess(); await CheckName(); _data.EnsureNoErrors(); var newTopic = new Topic { Name = _data.Name, Priority = (int)_data.Priority, IsActive = (bool)_data.IsActive }; try { await Db.AddAsync(newTopic); await Db.SaveChangesAsync(); } catch (Exception ex) { Logger.LogError(ex, "Cannot save new topic!"); throw Bad.UnknownError; } return(newTopic); }
public async Task <Domain.Token> GetToken(string contract, int tokenId) { var token = await Db.Tokens .SingleOrDefaultAsync(x => x.ContractAddress == contract && x.Token_id == tokenId); if (token != null) { return(token); } var tokenModel = Bcd.GetToken(contract, tokenId); if (tokenModel == null) { return(null); } token = new Domain.Token() { Decimals = tokenModel.decimals, Level = tokenModel.level, Name = tokenModel.name, Symbol = tokenModel.symbol, Token_id = tokenModel.token_id, ContractAddress = tokenModel.contract }; await Db.AddAsync(token); await Db.SaveChangesAsync(); return(token); }
public async Task RemoveResolvedReferenceAsyncShould_SettsIssuePropertyResolvedIssueToNull() { //Arrange var service = new ManagerIssueService(Db, null, null); var user = UserCreator.Create(null); await Db.AddAsync(user); var pic = ImageInfoCreator.Create(); await Db.AddAsync(pic); var issue = UrbanIssueCreator.CreateIssue(true, RegionType.Western, user.Id, pic.Id); await Db.AddAsync(issue); var resolved = ResolvedCreator.Create(user.Id, issue.Id, pic.Id); await Db.AddAsync(resolved); var hasResolvedBefore = issue.ResolvedIssue != null; //true //Act await service.RemoveResolvedReferenceAsync(issue.Id); var hasResolvedAfter = issue.ResolvedIssue != null; //false //Assert hasResolvedAfter.Should().BeFalse(); hasResolvedAfter.Should().IsSameOrEqualTo(!hasResolvedBefore); }
public async Task ApproveAsyncShould_ReturnsTrue_IfManagerRegionIsEqualToIssueRegion_OrManagerIsForAllRegionsAnd_SetsIssuePropertyIsApprovedToTrue() { //Arrange var manager = UserCreator.Create(RegionType.Western); await Db.AddAsync(manager); var issue = UrbanIssueCreator.CreateIssue(RegionType.Western, DefaultImageId); await Db.AddAsync(issue); await Db.SaveChangesAsync(); var activityService = new Mock <IManagerActivityService>(); var service = new ManagerIssueService(Db, null, activityService.Object); //Act var result = await service.ApproveAsync(manager, issue.Id); var dbEntryIsApproved = this.Db.UrbanIssues.FirstOrDefault(i => i.Id == issue.Id)?.IsApproved; //Assert result.Should().BeTrue(); dbEntryIsApproved.Should().BeTrue(); activityService.Verify(a => a.WriteLogAsync(It.IsAny <string>(), It.IsAny <ManagerActivityType>()), Times.Once); }
public async Task DeleteAsyncShould_ReturnsFalse_IfManagerRegionIsNotEqualToIssueRegion() { //Arrange var pictureService = IPictureServiceMock.New(DefaultImageId); var activityService = new Mock <IManagerActivityService>(); var service = new ManagerIssueService(Db, pictureService.Object, activityService.Object); var manager = UserCreator.Create(RegionType.Central); await Db.AddAsync(manager); var issue = UrbanIssueCreator.CreateIssue(RegionType.Western); await Db.AddAsync(issue); await Db.SaveChangesAsync(); //Act var result = await service.DeleteAsync(manager.Id, manager.ManagedRegion, issue.Id); //Assert result.Should().BeFalse(); pictureService.Verify(p => p.DeleteImageAsync(It.IsAny <int>()), Times.Never); activityService.Verify(a => a.WriteLogAsync(It.IsAny <string>(), It.IsAny <ManagerActivityType>()), Times.Never); }
public async Task <Models.Customer> PostAsync(Models.Customer customer) { var a = await _db.AddAsync(customer); await _db.SaveChangesAsync(); return(a.Entity); }
public async Task InsertAsync(T obj) { try { await Db.AddAsync(obj); } catch (Exception) { throw; } }
public async Task <object> Get(string type, int fill = 0) => await Task.Run <object>(async() => { object result; bool isFilling = fill == 1; switch (type.ToLower()) { case "salesitem": result = ModelFactory.SalesItem.Generate(); // Foreign key Constraint (result as SalesItem).MeasurementId = new Random().Next(1, 5); break; case "measurement": result = ModelFactory.Measurement.Generate(); break; case "staff": result = ModelFactory.Staff.Generate(); (result as Staff).RoleId = new Random().Next(1, 4); break; // case "salesrecord": // result = ModelFactory.SalesRecord.Generate(); // using (var db = new Db()) // { // var item = ModelFactory.SalesItem.Generate(); // (item as SalesItem).MeasurementId = new Random().Next(1, 5); // await db.SalesItems.AddAsync(item); // await db.SaveChangesAsync(); // (result as SalesRecord).ItemId = item.Id; // var sale = new Sale() {CreatedAt = DateTime.Now}; // await db.Sales.AddAsync(sale); // await db.SaveChangesAsync(); // (result as SalesRecord).SaleId = sale.Id; // } // break; default: throw new Exception("Invalid Type"); } if (isFilling) { using (var db = new Db()) { await db.AddAsync(result); await db.SaveChangesAsync(); } } return(result); });
private async Task AddFeature(Guid typeId, short sort, string title, string name, string value) { await Db.AddAsync(new MVDSubscriptionTypeFeature { SubscriptionTypeFeatureId = Guid.NewGuid(), SubscriptionTypeId = typeId, Description = string.Empty, IsFeature = true, Name = name, Title = title, Value = value, Sort = sort }); }
public async Task <Company> Register(CompanyModel cm, string userId) { try { var user = await UserManager.FindByIdAsync(userId); var dbskills = Db.Skills.Select(s => s.Name).ToList(); var skills = cm.Skills.Where(s => !dbskills.Contains(s)).Select(s => new Skill() { Name = s }); await Db.AddRangeAsync(skills); var company = new Company() { Name = cm.Name, Website = cm.Website, CIN = cm.CIN, Description = cm.Description, Sector = cm.Sector, EmployeeCount = cm.EmployeeCount, Established = cm.Established, SkillIds = string.Join(", ", skills.Select(s => s.Id)) }; var executive = new Executive() { CompanyId = company.Id, Firstname = user.Firstname, Lastname = user.Lastname, Email = user.Email, Mobile = user.PhoneNumber, }; await Db.AddAsync(executive); await Db.AddAsync(company); cm.Address.CompanyId = company.Id; await Db.AddAsync(cm.Address); await Db.SaveChangesAsync(); return(company); } catch (Exception ex) { return(null); } }
/// <exception cref="Bad"> /// <see cref="Bad.DataError"/>. /// </exception> /// <exception cref="Bad"> /// <see cref="Bad.UnknownError"/>. /// </exception> public async Task <Appeal> CreateAsync(CreateAppealData data) { _data = await data.ValidateAsync(Db); _data.EnsureNoErrors(); CheckTopic(); _data.EnsureNoErrors(); var newAppeal = new Appeal { TopicId = data.TopicId, Client = data.Client }; var firstMessageData = new CreateAppealMessageData { Content = data.FirstMessage, Appeal = newAppeal, Sender = newAppeal.Client }.Validate(); firstMessageData.EnsureNoErrors(); var firstMessage = new AppealMessage { Appeal = firstMessageData.Appeal, Sender = firstMessageData.Sender, Content = firstMessageData.Content, }; await Db.AddAsync(newAppeal); await Db.AddAsync(firstMessage); try { await Db.SaveChangesAsync(); } catch (Exception ex) { Logger.LogError(ex, "Can't create new Appeal with first AppealMessage!"); throw Bad.UnknownError; } return(newAppeal); }
public async Task <Models.AddressIndirection> PostAsync(Models.AddressIndirection AddressIndirection) { var a = await _db.AddAsync(new Models.AddressIndirection { CustomerId = AddressIndirection.CustomerId, Address = AddressIndirection.Address }); await _db.SaveChangesAsync(); return(new Models.AddressIndirection { Id = a.Entity.Id, Address = a.Entity.Address, CustomerId = a.Entity.CustomerId, Customer = new Models.Customer() }); }
public async Task <Models.PhoneNumberIndirection> PostAsync(Models.PhoneNumberIndirection PhoneNumberIndirection) { var a = await _db.AddAsync(new Models.PhoneNumberIndirection { CustomerId = PhoneNumberIndirection.CustomerId, PhoneNumber = PhoneNumberIndirection.PhoneNumber }); await _db.SaveChangesAsync(); return(new Models.PhoneNumberIndirection { Id = a.Entity.Id, CustomerId = a.Entity.CustomerId, PhoneNumber = a.Entity.PhoneNumber, Customer = new Models.Customer() }); }
public async Task <Quotation> Create(Quotation qr, string userId) { try { var user = await UserManager.FindByIdAsync(userId); var executive = await Db.Executives.FirstOrDefaultAsync(e => e.Email == user.Email); qr.CompanyId = executive.CompanyId; await Db.AddAsync(qr); await Db.SaveChangesAsync(); return(qr); } catch (Exception ex) { return(null); } }
public async Task AllAsyncShould_ReturnsApprovedAndNotApprovedIssuesWith_CorrectModel(bool isApproved, RegionType concreteRegion) { //Arrange var service = new ManagerIssueService(Db, null, null); var user = UserCreator.Create(null); await Db.AddAsync(user); var pic = ImageInfoCreator.Create(); await Db.AddAsync(pic); var issue = UrbanIssueCreator.CreateIssue(true, RegionType.Western, user.Id, pic.Id); var secondIssue = UrbanIssueCreator.CreateIssue(true, RegionType.Thracia, user.Id, pic.Id); var thirdIssue = UrbanIssueCreator.CreateIssue(false, RegionType.Western, user.Id, pic.Id); var fourthIssue = UrbanIssueCreator.CreateIssue(false, RegionType.North, user.Id, pic.Id); var fifthIssue = UrbanIssueCreator.CreateIssue(false, RegionType.Thracia, user.Id, pic.Id); var sixthIssue = UrbanIssueCreator.CreateIssue(false, RegionType.Western, user.Id, pic.Id); var seventhIssue = UrbanIssueCreator.CreateIssue(true, RegionType.South, user.Id, pic.Id); await Db.UrbanIssues.AddRangeAsync(issue, secondIssue, thirdIssue, fourthIssue, fifthIssue, sixthIssue, seventhIssue); await Db.SaveChangesAsync(); //Act //TODO: change test - no has new parameters - page and takeCount (int count, var resultAllRegions) = (await service.AllAsync <IssuesListingModel>(isApproved, RegionType.All, 1, 5)); var expectedAllRegions = await this.Db.UrbanIssues.Where(i => i.IsApproved == isApproved).ToListAsync(); (int countConcreteRegion, var resultConcreteRegion) = (await service.AllAsync <IssuesListingModel>(isApproved, concreteRegion, 1, 5)); var expectedConcreteRegion = await this.Db.UrbanIssues.Where(i => i.IsApproved == isApproved) .Where(i => i.Region == concreteRegion).ToListAsync(); //Assert resultAllRegions.Should().AllBeOfType <IssuesListingModel>(); resultAllRegions.Should().HaveCount(expectedAllRegions.Count); resultConcreteRegion.Should().HaveCount(expectedConcreteRegion.Count); resultConcreteRegion.Should().HaveCount(expectedConcreteRegion.Count); }
private async Task RequestAddFolderAsyncInner(StorageFolder folder) { // If this new folder is a subfolder, it shouldn't be added to db. var isSubFolder = await _musicFolders.Items.AnyAsync(x => folder.Path.StartsWith(x.Path)); if (isSubFolder) { await DialogService.NotificateAsync("Cannot add subfolder."); return; } // If this new folder is a parent folder, it shouldn't be added to db. var isParentFolder = await _musicFolders.Items.AnyAsync(x => x.Path.StartsWith(folder.Path)); if (isParentFolder) { await DialogService.NotificateAsync("Cannot add parent folder."); return; } var props = await folder.GetBasicPropertiesAsync(); var f = new Folder() { DateModified = props.DateModified, Path = folder.Path, NeedIndex = true, Token = StorageApplicationPermissions.FutureAccessList.Add(folder) }; await db.AddAsync(f); await db.SaveChangesAsync(); _musicFolders.AddOrUpdate(FolderViewModel.Create(f)); //Setting.AddOrUpdate(Setting.Collection.Indexing, true); }
/// <summary> /// Create a new database by loaded osu!db content /// </summary> /// <param name="dbInfo"></param> /// <param name="beatmaps"></param> /// <param name="token"></param> /// <returns></returns> private async ValueTask CreateDatabase(OsuDatabase dbInfo, List <OsuDatabaseBeatmap> beatmaps, CancellationToken token = default) { Logger.LogInformation("Creating database..."); await Db.AddAsync(dbInfo); await Db.SaveChangesAsync(); Logger.LogInformation($"Processing {dbInfo.BeatmapCount} beatmap..."); DateTimeOffset startTime = DateTimeOffset.Now; Db.RemoveRange(Db.OsuDatabaseBeatmap); await Db.SaveChangesAsync(); // Save all beatmaps foreach (var beatmap in beatmaps) { if (token.IsCancellationRequested) { return; } beatmap.OsuDatabaseId = dbInfo.Id; beatmap.OsuDatabaseTimings = null; beatmap.StarRatings = null; } // for performance, we save change every 5000 beatmaps foreach (var chunk in beatmaps.Chunk(5000)) { if (token.IsCancellationRequested) { return; } await Db.AddRangeAsync(chunk); await Db.SaveChangesAsync(); Logger.LogInformation($"Processed {chunk.Count} beatmap."); } Logger.LogInformation($"Create database complete in {(DateTimeOffset.Now - startTime).TotalMilliseconds}ms"); }
public async Task ApproveAsyncShould_ReturnsFalse_IfManagerRegionIsNotEqualToIssueRegion() { //Arrange var activityService = new Mock <IManagerActivityService>(); var service = new ManagerIssueService(Db, null, activityService.Object); var manager = UserCreator.Create(RegionType.Central); await Db.AddAsync(manager); var issue = UrbanIssueCreator.CreateIssue(RegionType.Western); await Db.AddAsync(issue); await Db.SaveChangesAsync(); //Act var result = await service.ApproveAsync(manager, issue.Id); //Assert result.Should().BeFalse(); activityService.Verify(a => a.WriteLogAsync(It.IsAny <string>(), It.IsAny <ManagerActivityType>()), Times.Never); }
public async Task DeleteAsyncShould_ReturnsFalse_IfManagerId_IsNotEqualTo_ResolvedPublisherId() { //Arrange var issueService = new Mock <IManagerIssueService>(); var pictureService = IPictureServiceMock.New(DefaultPicId); var activityService = new Mock <IManagerActivityService>(); var service = new ResolvedService(Db, issueService.Object, pictureService.Object, activityService.Object); var manager = UserCreator.Create(); var publisher = UserCreator.Create(); await Db.AddRangeAsync(manager, publisher); var issue = UrbanIssueCreator.CreateIssue(RegionType.All); await Db.AddAsync(issue); var resolved = ResolvedCreator.Create(publisher.Id, issue.Id, 0); await Db.AddAsync(resolved); await Db.SaveChangesAsync(); //Act var result = await service.DeleteAsync(manager.Id, resolved.Id); //Assert result.Should().BeFalse(); issueService.Verify(i => i.RemoveResolvedReferenceAsync(It.IsAny <int>()), Times.Never); pictureService.Verify(p => p.DeleteImageAsync(It.IsAny <int>()), Times.Never); activityService.Verify(a => a.WriteLogAsync(It.IsAny <string>(), It.IsAny <ManagerActivityType>()), Times.Never); }
private async ValueTask UpdateDatabase(OsuDatabase currentInfo, OsuDatabase newInfo, List <OsuDatabaseBeatmap> beatmaps, CancellationToken token = default) { Logger.LogInformation("Updating database..."); currentInfo.AccountLocked = newInfo.AccountLocked; currentInfo.BeatmapCount = newInfo.BeatmapCount; currentInfo.FolderCount = newInfo.FolderCount; currentInfo.Permission = newInfo.Permission; currentInfo.PlayerName = newInfo.PlayerName; currentInfo.UnlockedAt = newInfo.UnlockedAt; currentInfo.Version = newInfo.Version; Db.Update(currentInfo); await Db.SaveChangesAsync(); // these properties temporarily move out of the comprasion fields var emitSet = new HashSet <string>() { nameof(OsuDatabaseBeatmap.Id), nameof(OsuDatabaseBeatmap.OsuDatabaseId), nameof(OsuDatabaseBeatmap.OsuDatabase), nameof(OsuDatabaseBeatmap.StarRatings), nameof(OsuDatabaseBeatmap.OsuDatabaseTimings), nameof(OsuDatabaseBeatmap.LatestModifiedAt), nameof(OsuDatabaseBeatmap.LatestPlayedAt), nameof(OsuDatabaseBeatmap.LatestUpdateAt), }; var currentModifiedCount = 0; foreach (var beatmap in beatmaps) { if (token.IsCancellationRequested) { return; } // query exist record basic on FileName and FolderName var currentBeatmaps = await Db .OsuDatabaseBeatmap .Where((b) => (b.FileName == beatmap.FileName && b.FolderName == beatmap.FolderName) || (b.BeatmapSetId > 0 && b.BeatmapId > 0 && b.BeatmapSetId == beatmap.BeatmapSetId && b.BeatmapId == beatmap.BeatmapId)) .ToListAsync(); // no records that exist, save to database directly if (currentBeatmaps.Count == 0) { beatmap.OsuDatabaseId = currentInfo.Id; Logger.LogInformation($"Found new beatmap {beatmap.Artist} - {beatmap.Title} ({beatmap.FolderName}\\{beatmap.FileName})"); await Db.AddAsync(beatmap); } // exist 1 record, update else if (currentBeatmaps.Count == 1) { var currentBeatmap = currentBeatmaps[0]; if (Db.Entry(currentBeatmap).Update(beatmap, emitSet) > 0) { Logger.LogInformation($"Update beatmap {beatmap.Artist} - {beatmap.Title} ({beatmap.FolderName}\\{beatmap.FileName})"); } } // exist more than one record, delete old records and create again else { var corrupted = Db .OsuDatabaseBeatmap .Where((b) => b.FileName == beatmap.FileName && b.FolderName == beatmap.FolderName); Db.OsuDatabaseBeatmap.RemoveRange(corrupted); beatmap.OsuDatabaseId = currentInfo.Id; await Db.AddAsync(beatmap); Logger.LogInformation($"A corrupted data detected. Path = {beatmap.FolderName}\\{beatmap.FileName}"); } if (++currentModifiedCount % 500 == 0) { await Db.SaveChangesAsync(); } } Logger.LogInformation($"Update complete."); }
public async Task <IActionResult> Post([FromBody] MVMMonitorAlertSave value) { if (string.IsNullOrWhiteSpace(value.Title)) { return(Error("Title is required.")); } if (value.MonitorId == Guid.Empty) { return(Error("Monitor Id is required.")); } var monitor = await Db.Monitors.FirstOrDefaultAsync(x => x.MonitorId == value.MonitorId && x.UserId == UserId); if (monitor == null) { return(Error("Monitor not found.")); } MVDMonitorAlert data = null; if (value.Id != Guid.Empty) { data = await Db.MonitorAlerts.FirstOrDefaultAsync(x => x.MonitorId == monitor.MonitorId && x.MonitorAlertId == value.Id); if (data == null) { return(Error("Monitor alert not found.")); } } else { if (!await CheckSubscription(UserId, "ALERT_CHANNEL")) { return(Error("You don't have enough quota to do that.")); } data = new MVDMonitorAlert { MonitorAlertId = Guid.NewGuid(), MonitorId = monitor.MonitorId, Title = value.Title, ChannelType = value.ChannelType, Settings = JsonConvert.SerializeObject(value.Settings) }; await Db.AddAsync(data); } var result = await Db.SaveChangesAsync(); if (result > 0) { return(Success("Monitor alert saved successfully.", new { Id = data.MonitorAlertId })); } else { return(Error("Something is wrong with your model.")); } }
public async Task Update(User item) { _db.Remove(await _db.Users.FirstAsync(u => u.Id == item.Id)); await _db.AddAsync(item); }
public async Task <IActionResult> Post([FromRoute] Guid id, [FromQuery] string token) { if (id != Guid.Empty) { var subscriptionType = await Db.SubscriptionTypes.FirstOrDefaultAsync(x => x.SubscriptionTypeId == id); if (subscriptionType == null) { return(Error("Subscription type not found", code: 404)); } var subscription = await Db.Subscriptions.FirstOrDefaultAsync(x => x.UserId == UserId); if (subscription != null) { if (subscription.SubscriptionTypeId == subscriptionType.SubscriptionTypeId) { return(Error("You have already this subscription.")); } return(Success("We will add this feature.")); } else { subscription = new MVDSubscription { SubscriptionId = Guid.NewGuid(), SubscriptionTypeId = subscriptionType.SubscriptionTypeId, UserId = UserId, StartDate = DateTime.UtcNow, EndDate = subscriptionType.IsPaid ? DateTime.UtcNow.AddMonths(1) : DateTime.MinValue, PaymentPeriod = MVDPaymentPeriodTypes.Monthly }; await Db.AddAsync(subscription); var features = await Db.SubscriptionTypeFeatures.Where(x => x.SubscriptionTypeId == subscriptionType.SubscriptionTypeId).ToListAsync(); foreach (var feature in features) { await Db.AddAsync(new MVDSubscriptionFeature { SubscriptionFeatureId = Guid.NewGuid(), SubscriptionId = subscription.SubscriptionId, SubscriptionTypeId = subscriptionType.SubscriptionTypeId, SubscriptionTypeFeatureId = feature.SubscriptionTypeFeatureId, Description = feature.Description, Name = feature.Name, Value = feature.Value, Title = feature.Title, ValueUsed = string.Empty, ValueRemained = string.Empty }); } } if (subscriptionType.Price > 0) { try { var user = await Db.Users.FirstOrDefaultAsync(x => x.Id == UserId); var customerService = new CustomerService(); var customerResult = await customerService.CreateAsync(new CustomerCreateOptions { Email = user.Email, SourceToken = token }); var items = new List <SubscriptionItemOption> { new SubscriptionItemOption { PlanId = subscriptionType.Name } }; var subscriptionService = new SubscriptionService(); var subscriptionOptions = new SubscriptionCreateOptions { CustomerId = customerResult.Id, Items = items }; var subscriptionResult = await subscriptionService.CreateAsync(subscriptionOptions); if (subscriptionResult.Status == "active") { var payment = new MVDPayment { PaymentId = Guid.NewGuid(), Provider = "stripe", SubscriptionId = subscription.SubscriptionId, UserId = UserId, Token = subscriptionResult.LatestInvoiceId, Amount = subscriptionType.Price, Currency = "usd", Date = DateTime.UtcNow, Description = $"{subscriptionType.Title} {subscriptionType.Description}", }; await Db.AddAsync(payment); } else { return(Error("Payment not completed.", code: 400)); } } catch (Exception ex) { return(Error("Payment error. Please check your credit card and details.", internalMessage: ex.Message, code: 400)); } } if (await Db.SaveChangesAsync() > 0) { return(Success("Your subscription has been updated.")); } return(Error("There is nothing to save.")); } return(Error("You must send subscription id.")); }
public async Task <IActionResult> Get() { if (!await Db.SubscriptionTypes.AnyAsync()) { // Free var subscriptionTypeFree = new MVDSubscriptionType { SubscriptionTypeId = Guid.NewGuid(), IsPaid = false, Name = "free", Price = 0, Title = "Free", Description = "Free for starter users." }; await Db.AddAsync(subscriptionTypeFree); await AddFeature(subscriptionTypeFree.SubscriptionTypeId, 1, "monitor", "MONITOR", "1"); await AddFeature(subscriptionTypeFree.SubscriptionTypeId, 2, "monitor step", "MONITOR_STEP", "1"); await AddFeature(subscriptionTypeFree.SubscriptionTypeId, 3, "user", "USER", "1"); await AddFeature(subscriptionTypeFree.SubscriptionTypeId, 4, "interval", "INTERVAL", "300"); await AddFeature(subscriptionTypeFree.SubscriptionTypeId, 5, "alert channel", "ALERT_CHANNEL", "1"); // Startup var subscriptionTypeStartup = new MVDSubscriptionType { SubscriptionTypeId = Guid.NewGuid(), IsPaid = true, Name = "startup", Price = 4.99m, Title = "Startup", Description = "For startups." }; await Db.AddAsync(subscriptionTypeStartup); await AddFeature(subscriptionTypeStartup.SubscriptionTypeId, 1, "monitor", "MONITOR", "5"); await AddFeature(subscriptionTypeStartup.SubscriptionTypeId, 2, "monitor step", "MONITOR_STEP", "10"); await AddFeature(subscriptionTypeStartup.SubscriptionTypeId, 3, "user", "USER", "1"); await AddFeature(subscriptionTypeStartup.SubscriptionTypeId, 4, "interval", "INTERVAL", "300"); await AddFeature(subscriptionTypeStartup.SubscriptionTypeId, 5, "alert channel", "ALERT_CHANNEL", "2"); // Premium var subscriptionTypePremium = new MVDSubscriptionType { SubscriptionTypeId = Guid.NewGuid(), IsPaid = true, Name = "premium", Price = 49.99m, Title = "Premium", Description = "For growing companies." }; await Db.AddAsync(subscriptionTypePremium); await AddFeature(subscriptionTypePremium.SubscriptionTypeId, 1, "monitor", "MONITOR", "25"); await AddFeature(subscriptionTypePremium.SubscriptionTypeId, 2, "monitor step", "MONITOR_STEP", "100"); await AddFeature(subscriptionTypePremium.SubscriptionTypeId, 3, "user", "USER", "5"); await AddFeature(subscriptionTypePremium.SubscriptionTypeId, 4, "interval", "INTERVAL", "60"); await AddFeature(subscriptionTypePremium.SubscriptionTypeId, 5, "alert channel", "ALERT_CHANNEL", "5"); // Enterprise var subscriptionTypeEnterprise = new MVDSubscriptionType { SubscriptionTypeId = Guid.NewGuid(), IsPaid = true, Name = "enterprise", Price = 149.99m, Title = "Enterprise", Description = "For enterprise companies." }; await Db.AddAsync(subscriptionTypeEnterprise); await AddFeature(subscriptionTypeEnterprise.SubscriptionTypeId, 1, "monitor", "MONITOR", "100"); await AddFeature(subscriptionTypeEnterprise.SubscriptionTypeId, 2, "monitor step", "MONITOR_STEP", "250"); await AddFeature(subscriptionTypeEnterprise.SubscriptionTypeId, 3, "user", "USER", "25"); await AddFeature(subscriptionTypeEnterprise.SubscriptionTypeId, 4, "interval", "INTERVAL", "60"); await AddFeature(subscriptionTypeEnterprise.SubscriptionTypeId, 5, "alert channel", "ALERT_CHANNEL", "*"); if (await Db.SaveChangesAsync() > 0) { return(Success("I have bootstrapped successfuly.")); } } return(BadRequest("Done.")); }