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."));
}
