public async Task <IActionResult> RemoveSubscriptionAsync(int id, int subscriptionId)
{
List <SubscriptionDTO> subscriptions = await _subscriptionDAO.findByNetworkIdAsync(id);
SubscriptionDTO subscription = null;
System.Diagnostics.Trace.WriteLine("bar : " + id + " / " + subscriptionId);
foreach (SubscriptionDTO s in subscriptions)
{
System.Diagnostics.Trace.WriteLine("foo : " + s.Id);
if (s.Id == subscriptionId)
{
subscription = s;
}
}
if (subscription == null)
{
return(NotFound());
}
_subscriptionDAO.DeleteAsync(subscriptionId);
return(NoContent());
}
public IActionResult CreateSubscription(SubscriptionDTO subscription)
{
subscription.MemberId = (int)HttpContext.Session.GetInt32("MemberId");
subscription.Token = HttpContext.Session.GetString("JWTToken");
HttpClient client = new HttpClient();
client.BaseAddress = new Uri("http://localhost:53504");
var token = HttpContext.Session.GetString("JWTToken");
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
StringContent content = new StringContent(JsonConvert.SerializeObject(subscription), Encoding.UTF8, "application/json");
HttpResponseMessage response = client.PostAsync("/api/Subscription/Subscribe", content).Result;
if (response.StatusCode == HttpStatusCode.OK)
{
int MemberId = (int)HttpContext.Session.GetInt32("MemberId");
ViewBag.Id = MemberId;
string message = response.Content.ReadAsStringAsync().Result;
ViewBag.Message = message;
return(View());
}
else if (response.StatusCode == HttpStatusCode.Unauthorized)
{
return(Unauthorized());
}
else
{
string message = response.Content.ReadAsStringAsync().Result;
ViewBag.Message = message;
return(View());
}
}
public string InsertOrUpdate(SubscriptionDTO subscription)
{
try
{
var validate = Validate(subscription);
if (!string.IsNullOrEmpty(validate))
{
return(validate);
}
if (ObjectExists(subscription))
{
return(GenericMessages.DatabaseErrorRecordAlreadyExists + Environment.NewLine +
"With the same Name Exists");
}
_subscriptionRepository.InsertUpdate(subscription);
_unitOfWork.Commit();
return(string.Empty);
}
catch (Exception exception)
{
return(exception.Message);
}
}
public IActionResult CreateSubscription([FromBody] SubscriptionDTO dto)
{
var course = _context.Courses.SingleOrDefault(x => x.Id == dto.CourseId);
if (course == null)
{
return(NotFound("Course not found"));
}
var employee = _context.Employees.SingleOrDefault(x => x.Id == dto.EmployeeId);
if (employee == null)
{
return(NotFound("Employee not found"));
}
var subscription = new Subscription {
Course = course,
Employee = employee,
Status = true,
Date = DateTime.UtcNow
};
_context.Add(subscription);
_context.SaveChanges();
return(Ok());
}
public SubscriptionDTO AddSubscription(SubscriptionDTO subscriptionDto)
{
try
{
subscriptionDto.Validation();
var subscription = _mapper.Map <SubscriptionDTO, Subscription>(subscriptionDto);
subscription.CreateTime = DateTime.UtcNow;
if (Subscriptions.GetQuery().Where(
s => s.ExternalAccountId == subscription.ExternalAccountId &&
s.AccountId == subscription.AccountId &&
s.EventId == subscription.EventId &&
s.Url == subscription.Url &&
s.HttpMethod == subscription.HttpMethod &&
s.IsActual).Any())
{
throw new ValidationException(new List <string>()
{
"Subscription already exists."
});
}
Subscriptions.Create(subscription);
Subscriptions.Save();
subscriptionDto.Id = subscription.Id;
return(subscriptionDto);
}
catch (ValidationException ex)
{
throw ex;
}
}
public async Task <IActionResult> Post([FromBody] SubscriptionDTO subscription)
{
try
{
subscription.AccountId = int.Parse(User.FindFirst("accountId").Value);
SubscriptionDTO newSubscriptionDTO = SubscriptionService.AddSubscription(subscription); // попробовали добавить в базу в случае ошибки выкинет validationException
return(Ok(newSubscriptionDTO));
}
catch (ValidationException ex)
{
return(StatusCode(412,
new ProblemDetails()
{
Status = 412,
Title = ex.Message,
Detail = string.Join(string.Empty, ex.Errors)
})); // вернули 412 и ошибку
}
catch (Exception ex)
{
return(StatusCode(412,
new ProblemDetails()
{
Status = 412,
Title = ex.Message
}));
}
}
public bool ObjectExists(SubscriptionDTO subscription)
{
var objectExists = false;
var iDbContext = DbContextUtil.GetDbContextInstance();
try
{
var catRepository = new Repository <SubscriptionDTO>(iDbContext);
var catExists = catRepository.Query()
.Filter(bp => (bp.DisplayName == subscription.DisplayName) && bp.Id != subscription.Id)
.Get()
.FirstOrDefault();
if (catExists != null)
{
objectExists = true;
}
}
finally
{
iDbContext.Dispose();
}
return(objectExists);
}
// POST: /<controller>/
public async Task <IActionResult> PostSubscriptor([FromBody] SubscriptionDTO model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (_context.Subscriptions.Any(x => x.Auth == model.Keys["auth"]) == false)
{
Subscription subscription = new Subscription
{
Browser = _detection.Browser?.Name,
BrowserVersion = _detection.Browser?.Version?.Major,
PlatformVersion = _detection.Platform?.Version?.Major.ToString(),
Platform = _detection.Platform?.Type.ToString(),
Device = _detection.Device?.Type.ToString(),
EndPoint = model.EndPoint,
Auth = model.Keys["auth"],
Code = model.Keys["p256dh"],
ExpirationTime = model.ExpirationTime
};
var result = _context.Subscriptions.Add(subscription);
await _context.SaveChangesAsync();
return(CreatedAtAction("PostSubscriptor", new { id = subscription.Id }, subscription));
}
return(Ok());
}
public static Subscription FromDTO(SubscriptionDTO dto)
=> new Subscription
{
Id = dto.Id,
UserId = dto.UserId,
NetworkId = dto.NetworkId,
State = dto.State
};
public async Task <IActionResult> Subscribe([FromBody] SubscriptionDTO subscription, int id)
{
subscription.NetworkId = id;
SubscriptionDTO insertedPublication = await _subscriptionDAO.insertAsync(subscription);
return(new OkObjectResult(insertedPublication));
}
public async Task <SubscriptionDTO> Subscribe([FromBody] SubscriptionDTO subscriptionDTO)
{
var subscription = AutoMapper.Mapper.Map <Subscription>(subscriptionDTO);
var result = await _subscriptionRepository.Create(subscription);
return(AutoMapper.Mapper.Map <SubscriptionDTO>(result));
}
public SubscriptionDTO Create(SubscriptionDTO subscription)
{
Subscription record = mapper.Map <Subscription>(subscription);
db.Subscriptions.Add(record);
db.SaveChanges();
return(mapper.Map <SubscriptionDTO>(record));
}
public static List <SubscriptionDTO> getSubscriptionList()
{
using (Gymnastics_Studio_DataEntities GSDE = new Gymnastics_Studio_DataEntities())
{
List <Subscription> SubscriptionList = new List <Subscription>();
SubscriptionList = GSDE.Subscriptions.ToList();
return(SubscriptionDTO.ConvertListToDTO(SubscriptionList));
}
}
public void Insert(SubscriptionDTO subscription)
{
var subscriptionModel = ConvertToModel(subscription);
subscriptionModel.Enabled = true;
_subscriptionRepository.Insert(subscriptionModel);
_unityOfWork.Save();
}
public static SubscriptionDTO GetSubscriptionDetailsBySubscriptionId(int id)
{
using (Gymnastics_Studio_DataEntities GSDE = new Gymnastics_Studio_DataEntities())
{
Subscription Subscription = new Subscription();
Subscription = GSDE.Subscriptions.FirstOrDefault(x => x.Id == id);
return(SubscriptionDTO.ConvertToDTO(Subscription));
}
}
public static List <SubscriptionDTO> getSubscriptionListByStudent(int studentId)
{
using (Gymnastics_Studio_DataEntities GSDE = new Gymnastics_Studio_DataEntities())
{
string studentKind = GSDE.Students.Where(x => x.Id == studentId).FirstOrDefault().StudentKind;
List <Subscription> SubscriptionList = new List <Subscription>();
SubscriptionList = GSDE.Subscriptions.Where(x => x.StudensKind == studentKind).ToList();
return(SubscriptionDTO.ConvertListToDTO(SubscriptionList));
}
}
public static SubscriptionDTO ToDTO(this Subscription subscription)
{
var dto = new SubscriptionDTO
{
Model = subscription.Model,
ExpiryDate = subscription.ExpiryDate
};
return(dto);
}
public Task <SubscriptionDTO> Subscribe(SubscriptionDTO subscriptionDTO)
{
var client = new JsonServiceClient(BaseUrl);
client.AddHeader("Authorization", "Basic bXlfdXNlcm5hbWU6bXlfcGFzc3dvcmQ=");
var result = client.PostAsync <SubscriptionDTO>("/api/Subscription", subscriptionDTO);
return(result);
}
public string Validate(SubscriptionDTO subscription)
{
if (null == subscription)
{
return(GenericMessages.ObjectIsNull);
}
//if (String.IsNullOrEmpty(subscription.PlateNumber))
// return subscription.PlateNumber + " " + GenericMessages.StringIsNullOrEmpty;
return(string.Empty);
}
public bool CreateItem(string itemName)
{
var request = new RestRequest(Method.POST);
var sub = new SubscriptionDTO()
{
Name = itemName
};
request.AddJsonBody(sub);
var response = c.Execute(request);
return(response.IsSuccessful);
}
public SubscriptionDTO GetById(Guid id)
{
SubscriptionDTO result = null;
var subscription = _subscriptionRepository.GetById(id);
if (subscription != null)
{
result = ConvertToDto(subscription);
}
return(result);
}
public void SendNotification(SubscriptionDTO subscription, string message)
{
try
{
PushSubscription pushSubscription = new(subscription.Endpoint,
subscription.Keys.P256dh, subscription.Keys.Auth);
webPushClient.SendNotification(pushSubscription, message, vapidDetails);
}
catch (WebPushException)
{
// Subscription has expired or is no longer valid and should be removed.
}
}
public ActionResult Subscription([FromBody] SubscriptionDTO subscription)
{
string subscribeResult = _subscriptionService.Subscribe(subscription, subscription.Token);
if (subscribeResult == "Subscription Create")
{
return(Ok(subscribeResult));
}
else
{
return(BadRequest(subscribeResult));
}
}
public async Task <List <SubscriptionDTO> > findAllAsync()
{
IEnumerable <Subscription> subscriptions = await _context.Subscriptions.Find(_ => true).ToListAsync();
List <SubscriptionDTO> result = new List <SubscriptionDTO>();
foreach (Subscription subscription in subscriptions)
{
result.Add(SubscriptionDTO.FromSubscription(subscription));
}
return(result);
}
public string GetSubscriptionReport(int Id, int startVersion, int endVersion, string reportName)
{
IAuditReport report = new SubscriptionReport();
SubscriptionDTO result = report.GenerateReport(Id, startVersion, endVersion, reportName);
var json = JsonConvert.SerializeObject(result, Formatting.Indented,
new JsonSerializerSettings
{
ReferenceLoopHandling = ReferenceLoopHandling.Ignore
});
return(json);
}
public string SubscribeToNewsletter(SubscriptionDTO subscriptionDTO)
{
if (SubscriptionRepository.Get(s => s.SubscriberEmail == subscriptionDTO.SubscriberEmail).Any(s => s.SubscriptionType == SubscriptionType.Newsletter))
{
throw new ApplicationValidationErrorsException(new List <string> {
Resources.AppMessages.Subscription_Exists
});
}
Subscription subscription = SubscriptionFactory.CreateSubscription(subscriptionDTO.SubscriberName, subscriptionDTO.SubscriberEmail, subscriptionDTO.IsConfirmed);
SubscriptionRepository.Insert(subscription);
SubscriptionRepository.UnitOfWork.Commit();
return(subscription.ConfirmationToken);
}
public async Task <bool> Update(SubscriptionDTO dto)
{
Subscription original = await _context.Subscriptions
.Find(Builders <Subscription> .Filter.Eq(s => s.Id, dto.Id))
.FirstOrDefaultAsync();
Subscription subscription = Subscription.FromDTO(dto);
subscription._id = original._id;
ReplaceOneResult result = await _context.Subscriptions.ReplaceOneAsync(filter : u => u.Id == subscription.Id, replacement : subscription);
return(result.IsAcknowledged && result.ModifiedCount > 0);
}
public virtual MailMessage ConfirmSubscription(string token, string to, SubscriptionDTO subscriptionDTO)
{
var mailMessage = new MailMessage {
Subject = String.Format(Resources.EmailTemplates.SubscriptionMail_Subject, BgResources.Messages_SiteTitle)
};
ViewBag.Token = token;
ViewBag.Name = subscriptionDTO.SubscriberName;
ViewBag.Email = subscriptionDTO.SubscriberEmail;
mailMessage.To.Add(to);
mailMessage.From = new MailAddress(BgResources.Email_UserName);
PopulateBody(mailMessage, viewName: "ConfirmSubscription");
return(mailMessage);
}
public async Task <SubscriptionDTO> insertAsync(SubscriptionDTO dto)
{
Counter counter = await _counterDAO.GetCountersAsync();
int id = counter.Subscriptions++;
await _counterDAO.UpdateCountersAsync(counter);
Subscription subscription = Subscription.FromDTO(dto);
subscription.Id = id;
await _context.Subscriptions.InsertOneAsync(subscription);
return(SubscriptionDTO.FromSubscription(subscription));
}
public async Task <List <SubscriptionDTO> > findByUserIdAsync(int userId)
{
List <Subscription> subscriptions = await _context.Subscriptions
.Find(Builders <Subscription> .Filter.Eq(s => s.UserId, userId))
.ToListAsync();
List <SubscriptionDTO> result = new List <SubscriptionDTO>();
foreach (Subscription subscription in subscriptions)
{
result.Add(SubscriptionDTO.FromSubscription(subscription));
}
return(result);
}
