public List <SubscriptionDto> GetAllSubscription(SubscriptionDto input)
{
var query = (from subscription in _context.Subscription.ToList()
join user in _context.UserProfile.ToList()
on subscription.UserProfileId equals user.Id
select new SubscriptionDto
{
Username = user.userEmail,
Name = subscription.Name,
Id = subscription.Id,
DateCreated = subscription.DateCreated,
Status = subscription.Status,
UserId = subscription.UserId
}).ToList();
// Map Records
List <SubscriptionDto> ratingDto = MappingProfile.MappingConfigurationSetups().Map <List <SubscriptionDto> >(query);
if (input.PagedResultDto != null)
{
//Apply Sort
ratingDto = Sort(input.PagedResultDto.Sort, input.PagedResultDto.SortOrder, ratingDto);
// Apply search
if (!string.IsNullOrEmpty(input.PagedResultDto.Search))
{
ratingDto = ratingDto.Where(p => p.Status != null && p.Status.ToLower().ToString().ToLower().Contains(input.PagedResultDto.Search.ToLower()) ||
p.Username != null && p.Username.ToString().ToLower().Contains(input.PagedResultDto.Search.ToLower()) ||
p.DateCreated != null && p.DateCreated.ToString().ToLower().Contains(input.PagedResultDto.Search.ToLower()) ||
p.Name != null && p.Name.ToString().ToLower().ToString().Contains(input.PagedResultDto.Search.ToLower())
).ToList();
}
}
return(ratingDto);
}
public IQueryable <SubscriptionDto> Subscriptions([FromBody] SubscriptionBasketModel model)
{
var list = new List <SubscriptionDto>();
var user = GetUser(model.User.Id);
if (user != null)
{
var courses = Db.Activities.OfType <Course>().Where(x => x.Occurrence.Subscriptions.Any(s => s.UserId.Equals(user.Id))).ToList();
foreach (var course in courses)
{
var subscription =
course.Occurrence.Subscriptions.FirstOrDefault(x => x.UserId.Equals(model.User.Id));
var subModel = new SubscriptionDto();
subModel.CourseId = course.Id;
subModel.IsValid = true;
subModel.OnWaitingList = subscription.OnWaitingList;
list.Add(subModel);
}
}
return(list.AsQueryable());
}
protected virtual async Task Create(SubscriptionDto input)
{
Subscription tagDto = MappingProfile.MappingConfigurationSetups().Map <Subscription>(input);
_context.Subscription.Add(tagDto);
await _context.SaveChangesAsync();
}
public async Task <ISubscription> AddSubscriptionAsync(SubscriptionDto subscriptionDto)
{
await _subscriptionDtoValidator.ValidateAndThrowAsync(subscriptionDto);
var name = subscriptionDto.Name;
var amount = subscriptionDto.Amount;
if (await GetSubscriptionAsync(name, amount) != null)
{
throw new AiofFriendlyException(HttpStatusCode.BadRequest,
$"{nameof(Subscription)} with Name={name} and Amount={amount} already exists");
}
var subscription = _mapper.Map <Subscription>(subscriptionDto);
subscription.UserId = _tenant.UserId;
await _context.Subscriptions.AddAsync(subscription);
await _context.SaveChangesAsync();
_logger.LogInformation("{Tenant} | Created Subscription with Id={SubscriptionId}, PublicKey={SubscriptionPublicKey} and UserId={SubscriptionUserId}",
_tenant.Log,
subscription.Id,
subscription.PublicKey,
subscription.UserId);
return(subscription);
}
public async Task <ActionResult> SignUp(SignUpViewModel model)
{
if (ModelState.IsValid)
{
var user = new AppUser {
UserName = model.UserName, Email = model.Email
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
// --- Sign in the user
await SignInManager.SignInAsync(user, false, false);
// --- Create the subscription for the user
var subscrSrv = ServiceManager.GetService <ISubscriptionService>();
var newSubscr = new SubscriptionDto
{
SubscriberName = user.UserName,
PrimaryEmail = user.Email,
CreatedUtc = DateTimeOffset.UtcNow,
};
var subscriptionId = await subscrSrv.CreateSubscriptionAsync(newSubscr, user.Id);
CreateAuthenticationTicket(false, new Guid(user.Id), user.UserName, false, subscriptionId, true);
return(RedirectToAction("SelectSubscriptionPackage"));
}
AddErrors(result);
}
return(View(model));
}
public IActionResult ExtendSubscriptionPaypal([FromBody] PaypalPaymentRequest paymentRequest)
{
Console.WriteLine(paymentRequest.paymentNonce);
Braintree.TransactionRequest request = new Braintree.TransactionRequest()
{
PaymentMethodNonce = paymentRequest.paymentNonce,
Amount = (decimal)(paymentRequest.amount)
};
Braintree.Result <Braintree.Transaction> result = gateway.Transaction.Sale(request);
if (result.IsSuccess())
{
TransactionDto transaction = new TransactionDto();
transaction.Amount = (decimal)(paymentRequest.amount);
transaction.Status = "succeeded";
transaction.CustomerId = 1;
transaction.PaymentGatewayId = 2;
transaction.PricingPackageId = paymentRequest.packageId;
transaction.DateCreated = DateTime.Now;
_transactionManipulation.SaveTransaction(transaction);
SubscriptionDto subscription = _subscriptionManipulation.GetCustomerSubscription(1);
subscription.SubscriptionExpirationDate = subscription.SubscriptionExpirationDate.AddMonths(1);
_subscriptionManipulation.UpdateSubscription(subscription);
return(Ok("Uspjesan placanje"));
}
else
{
return(BadRequest("Neuspjesna transakcija!"));
}
}
public async Task ChangeSubscription(SubscriptionDto subscriptionDto, long companyId)
{
var company = await _context.Companies
.Include(c => c.Subscriptions)
.SingleOrDefaultAsync(c => c.Id == companyId);
if (company == null)
{
throw new NotFoundException("Компания с таким Id не найдена");
}
company.Subscriptions ??= new List <Subscription>();
foreach (var subscription in company.Subscriptions)
{
subscription.Active = false;
}
company.Subscriptions.Add(new Subscription
{
TariffId = subscriptionDto.TariffId,
StartDate = subscriptionDto.StartDate,
EndDate = subscriptionDto.EndDate,
Active = true
});
await _context.SaveChangesAsync();
}
public IActionResult Post([FromBody] SubscriptionDto subscription)
{
try
{
if (ModelState.IsValid)
{
// Ovdje bi vjerovatno trebalo povuci subscriptione radi eventualne provjere
subscription.SubscriptionStartDate = new DateTime();
subscription.SubscriptionExpirationDate = subscription.SubscriptionStartDate;
var result = _subscriptionManipulation.SaveSubscription(subscription);
if (result != null)
{
return(Ok(result));
}
}
else
{
return(BadRequest(subscription));
}
}
catch (Exception e)
{
Logger.Logger.LogError(e.Message);
}
return(BadRequest());
}
public void SubscriptionWorker(int nodeId, string subs, string personId)
{
//var objEntitySource = (from a in ctx.Person
// where a.v_PersonId == personId
// select a).FirstOrDefault();
//objEntitySource.v_Subs = subs;
//ctx.SaveChanges();
using (var dbContext = new DatabaseContext())
{
var objEntity = new SubscriptionDto();
objEntity.v_PersonId = personId;
objEntity.v_Subs = subs;
objEntity.i_IsDeleted = (int)Enumeratores.SiNo.No;
objEntity.d_InsertDate = DateTime.Now;
//Autogeneramos el Pk de la tabla
objEntity.v_SubscriptionId = new Common.Utils().GetPrimaryKey(nodeId, 361, "SP");
dbContext.Subscription.Add(objEntity);
dbContext.SaveChanges();
}
}
public IQueryable <SubscriptionDto> Subscriptions([FromBody] SubscriptionCourseModel model)
{
var studService = new StudentService(Db);
var semService = new SemesterService(Db);
var list = new List <SubscriptionDto>();
var user = GetUser(model.Id.ToString());
var student = studService.GetCurrentStudent(user.Id);
var semester = semService.GetSemester(DateTime.Today);
var courses = Db.Activities.OfType <Course>().Where(a =>
a.SemesterGroups.Any(g => g.Semester.Id == semester.Id) &&
a.Occurrence.Subscriptions.Any(u => u.UserId.Equals(user.Id))).ToList();
foreach (var course in courses)
{
var subscription =
course.Occurrence.Subscriptions.FirstOrDefault(x => x.UserId.Equals(user.Id));
var subModel = new SubscriptionDto();
subModel.CourseId = course.Id;
subModel.IsValid = true;
subModel.OnWaitingList = subscription.OnWaitingList;
subModel.Title = course.Name;
list.Add(subModel);
}
return(list.AsQueryable());
}
private void AplyDtoToEntity(Subscription subscription, SubscriptionDto subscriptionDto)
{
subscription.LastDay = subscriptionDto.LastDay;
subscription.Price = subscriptionDto.Price;
subscription.TeamId = subscriptionDto.TeamId;
subscription.VisorId = subscriptionDto.VisorId;
}
public IQueryable <SubscriptionDto> Courses([FromBody] SubscriptionCourseModel model)
{
var memberService = new MemberService(Db);
var semService = new SemesterService(Db);
var teachingService = new TeachingService(Db);
var list = new List <SubscriptionDto>();
var user = GetUser(model.Id.ToString());
var members = memberService.GetFacultyMemberships(user.Id);
var semester = semService.GetSemester(DateTime.Today);
var teaching = teachingService.GetActivities(semester, user, members);
foreach (var course in teaching.Courses)
{
var subModel = new SubscriptionDto();
subModel.CourseId = course.Course.Id;
subModel.Title = course.Course.Name;
list.Add(subModel);
}
return(list.AsQueryable());
}
public async Task <IActionResult> Create(SubscriptionDto pSubscriptionDto)
{
using (HttpClient httpClient = new HttpClient())
{
var content = new StringContent(JsonConvert.SerializeObject(pSubscriptionDto), Encoding.UTF8, "application/json");
var response = await httpClient.PostAsync($"http://localhost:50106/api/v1/subscriptions/", content);
}
return(RedirectToAction("Index"));
}
public void UpdateSubscription(SubscriptionDto pSubscriptionDto)
{
Models.Subscription subscriptionToModify = _paraContext.Subscriptions.Where(s => s.Year == pSubscriptionDto.Id).FirstOrDefault();
subscriptionToModify.SubscriptionAmount = pSubscriptionDto.Amount;
_paraContext.Subscriptions.Update(subscriptionToModify);
_paraContext.SaveChanges();
}
public void Put_ReturnsNOK()
{
var controller = new SubscriptionController(ism);
// Act
SubscriptionDto sub = new SubscriptionDto();
var result = controller.Put(sub);
// Assert
Assert.IsType <BadRequestResult>(result);
}
public async Task <IActionResult> PostSubscription([FromBody] SubscriptionDto request)
{
var update = request.ToUpdate();
var subscription = await subscriptionStore.UpsertAsync(App.Id, UserId, request.TopicPrefix, update, HttpContext.RequestAborted);
var response = SubscriptionDto.FromDomainObject(subscription);
return(Ok(response));
}
public static SubscriptionSearchIndex CreateSearchIndex(this SubscriptionDto article)
{
return(new SubscriptionSearchIndex
{
Id = article.Id.Value,
Description = article.Description,
FiscalSetupId = article.FiscalSetupId,
Details = article.Details
});
}
public async Task <int> Update(SubscriptionDto subscriptionDto)
{
Subscription subscription = _subscriptionsDbContext.Subscriptions.Find(subscriptionDto.Id);
AplyDtoToEntity(subscription, subscriptionDto);
await _subscriptionsDbContext.SaveChangesAsync();
return(subscription.Id);
}
public async Task <Feed> PostAsync([FromBody] SubscriptionDto subscriptionDto)
{
var subscription = Mapper.Map <Subscription>(subscriptionDto);
if (!string.IsNullOrEmpty(subscriptionDto.FeedId))
{
return(await Registration.AddSubscriptionToFeed(subscription, new Guid(subscriptionDto.FeedId)));
}
return(await Registration.AddSubscriptionToFeed(subscription, null));
}
protected virtual async Task Update(SubscriptionDto input)
{
var tags = await _context.Subscription.Where(x => x.Id == input.Id).FirstOrDefaultAsync();
if (tags != null)
{
Subscription tagDto = MappingProfile.MappingConfigurationSetups().Map <Subscription>(input);
_context.Subscription.Update(tagDto);
await _context.SaveChangesAsync();
}
}
public async Task CreateOrEditSubscription(SubscriptionDto input)
{
if (input.Id == null || input.Id == 0)
{
await Create(input);
}
else
{
await Update(input);
}
}
public async Task <int> Create(SubscriptionDto subscriptionDto)
{
Subscription subscription = new Subscription();
AplyDtoToEntity(subscription, subscriptionDto);
_subscriptionDbContext.Subscriptions.Add(subscription);
await _subscriptionsDbContext.SaveChangesAsync();
return(subscription.Id);
}
public void CreateSubscription(SubscriptionDto pSubscriptionDto)
{
_paraContext.Subscriptions.Add(new Models.Subscription
{
Year = pSubscriptionDto.Id,
IsActive = true,
SubscriptionAmount = pSubscriptionDto.Amount
});
_paraContext.SaveChanges();
}
SubscriptionDto ISubscriptionRepository.SaveSubscription(SubscriptionDto subscription)
{
var newSubscription = MapToDbEntity(subscription);
_dbContext.Subscription.Add(newSubscription);
if (_dbContext.SaveChanges() != 0)
{
return(MapToDto(newSubscription));
}
return(null);
}
public async Task <ActionResult <SubscriptionDto> > Subscribe([FromBody] PushSubscriptionRequest request)
{
var subscription = new SubscriptionDto
{
Endpoint = request.Subscription.Endpoint,
ExpirationTime = request.Subscription.ExpirationTime,
Auth = request.Subscription.Keys.Auth,
P256Dh = request.Subscription.Keys.P256Dh
};
return(await _pushService.Subscribe(subscription, _userContextService.GetCurrentUser().Id));
}
SubscriptionDto ISubscriptionRepository.UpdateSubscription(SubscriptionDto subscription)
{
var pendingSubscription = _dbContext.Subscription.FirstOrDefault(s => s.SubscriptionId == subscription.SubscriptionId);
if (pendingSubscription != null)
{
pendingSubscription.IsActive = subscription.IsActive;
pendingSubscription.RecurringPayment = subscription.RecurringPayment;
pendingSubscription.SubscriptionExpirationDate = subscription.SubscriptionExpirationDate;
}
_dbContext.SaveChanges();
return(MapToDto(pendingSubscription));
}
public async Task <IActionResult> GetSubscription(string topic)
{
var subscription = await subscriptionStore.GetAsync(App.Id, UserId !, topic, HttpContext.RequestAborted);
if (subscription == null)
{
return(NotFound());
}
var response = SubscriptionDto.FromDomainObject(subscription);
return(Ok(response));
}
public static Subscription MapToDbEntity(SubscriptionDto subscription)
{
return(new Subscription()
{
SubscriptionId = subscription.SubscriptionId,
PricingPackageId = subscription.PricingPackageId,
CustomerId = subscription.CustomerId,
SubscriptionStartDate = subscription.SubscriptionStartDate,
SubscriptionExpirationDate = subscription.SubscriptionExpirationDate,
IsActive = subscription.IsActive,
RecurringPayment = subscription.RecurringPayment
});
}
public async Task <SubscriptionDto> GetSubscriptionForEdit(SubscriptionDto input)
{
var users = await _context.Subscription.Where(x => x.Id == input.Id).FirstOrDefaultAsync();
if (users != null)
{
Subscription tagDto = MappingProfile.MappingConfigurationSetups().Map <Subscription>(input);
_context.Subscription.Update(tagDto);
await _context.SaveChangesAsync();
return(MappingProfile.MappingConfigurationSetups().Map <SubscriptionDto>(tagDto));
}
return(new SubscriptionDto());
}
public async Task <IActionResult> Add([FromBody] SubscriptionRequest request)
{
if (string.IsNullOrEmpty(request?.Email))
{
return(BadRequest());
}
try
{
var subscription = await _unitOfWork.Subscriptions.GetFirstOrDefault(s =>
s.Email.ToLower() == request.Email.ToLower());
if (subscription == null)
{
subscription = new SubscriptionDto
{
Email = request.Email,
IsSubscribed = true,
SubscribeDate = DateTime.UtcNow
};
await _unitOfWork.Subscriptions.Add(subscription);
_emailService.SendWelcomeAsync(subscription.Email);
}
else
{
if (subscription.IsSubscribed)
{
return(Json(new { exist = true, message = "You are already subscribed, but thank you!" }));
}
subscription.IsSubscribed = true;
await _unitOfWork.Subscriptions.Update(subscription);
await _unitOfWork.Save();
_emailService.SendWelcomeBackAsync(subscription.Email).ConfigureAwait(false);
return(Json(new { exist = true, message = "Welcome back, Friend! Thank you!" }));
}
}
catch (Exception e)
{
_logger.LogError(e, "Cannot subscribe");
throw;
}
await _unitOfWork.Save();
return(Ok());
}
