public Subscription GetSubscription(SubscribeViewModel vm)
{
using (var conn = Connection)
{
conn.Open();
using (var cmd = conn.CreateCommand())
{
cmd.CommandText = @"SELECT TOP 1 * FROM Subscription
WHERE SubscriberUserProfileId = @subscriberId AND ProviderUserProfileId = @providerId AND EndDateTime IS NULL";
cmd.Parameters.AddWithValue("@subscriberId", vm.SubscriberUserId);
cmd.Parameters.AddWithValue("@providerId", vm.ProviderUserId);
var reader = cmd.ExecuteReader();
Subscription subscription = new Subscription();
if (reader.Read())
{
subscription.Id = reader.GetInt32(reader.GetOrdinal("Id"));
subscription.SubscriberUserProfileId = reader.GetInt32(reader.GetOrdinal("SubscriberUserProfileId"));
subscription.ProviderUserProfileId = reader.GetInt32(reader.GetOrdinal("ProviderUserProfileId"));
subscription.BeginDateTime = reader.GetDateTime(reader.GetOrdinal("BeginDateTime"));
subscription.EndDateTime = DbUtils.GetNullableDateTime(reader, "EndDateTime");
}
reader.Close();
return(subscription);
}
}
}
private void FormLogin_Load(object sender, EventArgs e)
{
if (DesignMode)
{
return;
}
m_viewModel = new SubscribeViewModel();
m_viewModel.UserName = Framework.Environment.CurUserInfo.UserName;
m_viewModel.ClientIP = Framework.Environment.LocalCommIP;
m_viewModel.ClientPort = Framework.Environment.AlarmReceivePort;
foreach (var item in m_viewModel.BlackListLibs)
{
DevComponents.DotNetBar.Controls.CheckBoxX checkBoxX = new DevComponents.DotNetBar.Controls.CheckBoxX();
checkBoxX.BackgroundStyle.CornerType = DevComponents.DotNetBar.eCornerType.Square;
checkBoxX.AutoSize = true;
checkBoxX.Style = DevComponents.DotNetBar.eDotNetBarStyle.StyleManagerControlled;
checkBoxX.TabIndex = 0;
checkBoxX.Text = item.Name + "[" + item.PicCount + "]";
checkBoxX.Tag = new Tuple <uint, uint>(item.Handel, 0);
checkBoxX.CheckedChangedEx += checkBoxX_CheckedChangedEx;
flowLayoutPanel1.Controls.Add(checkBoxX);
}
advTree1.DataSource = m_viewModel.FaceSubscribe;
}
public async Task <ActionResult> Subscribe(SubscribeViewModel model)
{
var currentUser = UserManager.FindById(User.Identity.GetUserId());
model.Email = currentUser.Email;
if (ModelState.IsValid)
{
var client = new LicensingService.Service1Client();
var newSerial = client.GetNewSerial();
// user XX features XX databases XX - xxxx
model.Serial = model.Users.ToString("D2") + model.Features.ToString("D2") + model.Databases.ToString("D2") + "-" + newSerial;
LicensingService.SubscribeViewModel subscription = new LicensingService.SubscribeViewModel()
{
Email = model.Email,
Users = model.Users,
Databases = model.Databases,
Features = model.Features,
Serial = model.Serial
};
client.AddSubscription(subscription);
return(View("SubscribeConfirm", model));
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <IActionResult> Create([FromBody] SubscribeViewModel record)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
SubscriberModel subscriberModel = new SubscriberModel
{
Code = record.Code,
Name = record.Name,
Emails = record.Emails,
Remarks = record.Remarks
};
try
{
var createdRecord = (await this._AppService.Create(subscriberModel));
return(Created($"api/[controller]/{ createdRecord.Id }", createdRecord));
}
catch (ApplicationException ex)
{
return(new BadRequestObjectResult(ex));
}
}
public async ValueTask <IActionResult> Subscribe([FromBody] SubscribeViewModel viewModel)
{
if (viewModel.Email != null)
{
bool result;
var checker = await _repo.Newsletters.FirstOrDefaultAsync(x => x.Email == viewModel.Email);
if (checker != null && !checker.IsSubsribed)
{
checker.IsSubsribed = true;
_repo.Newsletters.Update(checker);
await _repo.SaveChangesAsync();
result = true;
}
else
{
var model = new Newsletter {
Email = viewModel.Email, IsSubsribed = true
};
_repo.Newsletters.Add(model);
await _repo.SaveChangesAsync();
result = true;
}
if (result)
{
return(NoContent());
}
}
return(BadRequest());
}
public async Task <SubscribeViewModel> LoadSubscribeViewModel(bool loadTags = true, bool loadNewsletters = true)
{
var model = new SubscribeViewModel();
await LoadAsync(model);
model.Sectors = await Repository.GetSectorsAsync();
try
{
if (loadTags)
{
model.Tags = await Repository.ApiClient.Subscribe.SubscriptionItemsAsync("tags", Repository.APIVersion);
}
}
catch (Exception) { }
if (loadNewsletters)
{
model.Newsletters = await Repository.GetNewslettersAsync();
}
// As per Michael's instructions we're hard-coding these values and not fetching them from a table in a DB
var emergencies = new List <KeyValuePair2>();
emergencies.Add(new KeyValuePair2("alerts", "Emergency Alerts"));
//emergencies.Add(new KeyValuePair<string, string>("campaigns", "Campaigns"));
model.Emergencies = emergencies;
return(model);
}
public async Task <IActionResult> Subscribe(SubscribeViewModel model)
{
if (string.IsNullOrEmpty(model.Email) || !(await IsValidAsync(model.Email)))
{
return(Json(new { result = false, Error = "Email field is empty" }));
}
var dbSet = _context.Set <Subscriber>();
var entry = await dbSet.FirstOrDefaultAsync(s => s.Email == model.Email);
if (entry == null)
{
entry = (await dbSet.AddAsync(new Subscriber
{
Name = model.Email,
Email = model.Email,
EmailSend = true,
DateCreated = DateTime.Now,
Culture = CultureInfo.CurrentUICulture.ToString()
})).Entity;
}
else
{
if (entry.Unsubscribe)
{
entry.Unsubscribe = false;
}
else
{
return(Json(new { result = false, Error = "User is already subscribed to the newsletter" }));
}
}
await _context.SaveChangesAsync();
_slack.Post(new SlackMessage
{
Attachments = new List <SlackAttachment> {
new SlackAttachment
{
Color = "#120a8f",
Title = $"Подписка пользователя {entry.Name}",
TitleLink = $"mailto:{entry.Email}",
Fields = new List <SlackField>
{
new SlackField {
Title = $"Подписка: {(entry.Unsubscribe ? "Нет":"Да")}",
Value = $"Email: {entry.Email}",
Short = false
}
},
Pretext = $"Дата регистрации: {entry.DateCreated.ToString("dd:MM:yyyy HH:mm")}"
}
}
});
//var sendResult = await _emailSender.SendEmailSubscription(model.Email, model.Email);
return(Json(new { result = true /*sendResult*/, Error = "" }));
}
public string Subscribe(SubscribeViewModel model)
{
if (ModelState.IsValid)
{
return($"{model.Email} - subscribed");
}
return("Upss");
}
public void TestConstructor_ShouldSetLogIdCorrectly(bool isSubscribed, int logId)
{
// Arrange, Act
var model = new SubscribeViewModel(isSubscribed, logId);
// Assert
Assert.AreEqual(logId, model.LogId);
}
public async Task <IActionResult> Subscribe()
{
SubscribeViewModel model = new SubscribeViewModel
{
Stats = await GetStats()
};
return(View(model));
}
public async Task <SubscribeViewModel> Subscribe(SubscribeViewModel model, CancellationToken cancellationToken)
{
await _jobService.SubscribeAsync(model.EmailAddress, cancellationToken);
return(new SubscribeViewModel()
{
Confirmation = true
});
}
public ActionResult Subscribe(int id, string returnUrl)
{
var category = _repositories.Categories.Get(id);
var model = SubscribeViewModel.CreateViewModel(category, returnUrl);
model.ReturnUrl = Request.UrlReferrer == null ? null : Request.UrlReferrer.PathAndQuery;
return(View(model));
}
public async Task <IActionResult> Subscribe(SubscribeViewModel model)
{
if (!this.ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var answer = await this._userAppService.Subscribe(model);
return(Created($"api/user/{ answer }", answer));
}
public async Task <ActionResult> Manage(string token)
{
SubscriberInfo info = null;
var guid = UrlTokenDecode(token);
if (guid.HasValue)
{
info = await Repository.ApiClient.Subscribe.ConfirmUpdateCreateSubscriptionAsync(guid.Value, Repository.APIVersion);
if (info == null)
{
return(Redirect(new Uri(new Uri(Configuration["NewsHostUri"]), "subscribe").ToString()));
}
}
SubscribeViewModel model = await LoadSubscribeViewModel();
model.Selection = new SelectionModel();
if (info != null)
{
model.Selection.EmailAddress = info.EmailAddress;
if (info.SubscribedCategories != null)
{ // we have a valid token
model.Token = guid;
model.Selection.NewsAsItHappens = info.IsAsItHappens.Value;
model.Selection.NewsDailyDigest = info.IsDailyDigest.Value;
IList <string> lists;
if (info.IsAllNews.Value)
{
model.Selection.Ministries = model.Ministries.Select(m => m.Index.Key);
model.Selection.Sectors = model.Sectors.Select(m => m.Index.Key);
model.Selection.Tags = model.Tags.Select(m => m.Key);
}
else
{
model.Selection.Ministries = info.SubscribedCategories.TryGetValue("ministries", out lists) ? lists : new string[0];
model.Selection.Sectors = info.SubscribedCategories.TryGetValue("sectors", out lists) ? lists : new string[0];
model.Selection.Tags = info.SubscribedCategories.TryGetValue("tags", out lists) ? lists : new string[0];
}
model.Selection.Services = info.SubscribedCategories.TryGetValue("services", out lists) ? lists : new string[0];
model.Selection.Emergency = info.SubscribedCategories.TryGetValue("emergency", out lists) ? lists : new string[0];
model.Selection.Newsletters = info.SubscribedCategories.TryGetValue("newsletters", out lists) ? lists : new string[0];
model.Selection.MediaDistributionLists = info.SubscribedCategories.TryGetValue("media-distribution-lists", out lists) ? string.Join(";", lists) : null;
}
}
return(View(model));
}
// Having these parameters will make ASP MVC create (auto magically) them
// using the request query parameters
public async Task <ActionResult> Index(string[] ministries, string[] sectors, string[] tags, string[] services, string[] emergency, string[] newsletters, string display)
{
bool servicesSelected = services.Any();
if (servicesSelected || newsletters.Any())
{
// do not show Ministries and Sectors
ministries = null;
sectors = null;
emergency = null;
if (servicesSelected)
{
newsletters = null;
}
else
{
services = null;
}
}
else
{
newsletters = null;
services = null;
}
if ((ministries?.Length ?? 0) == 0 && (sectors?.Length ?? 0) == 0 && (services?.Length ?? 0) == 0 && (emergency?.Length ?? 0) == 0 && (newsletters?.Length ?? 0) == 0)
{
if ((tags?.Length ?? 0) == 0)
{
if (!string.IsNullOrEmpty(display))
{
return(StatusCode(400));
}
}
else
{
if (string.IsNullOrEmpty(display))
{
display = "selected";
}
}
}
SubscribeViewModel model = await LoadSubscribeViewModel(ministries != null, newsletters != null, services != null);
model.Selection = new SelectionModel {
Ministries = ministries, Sectors = sectors, Tags = tags, Services = services, NewsAsItHappens = true, Emergency = emergency, Newsletters = newsletters
};
model.Display = display;
return(View(model));
}
/*public void EditDatabase(SubscribeViewModel changes)
{
Subscriber subscriber = db.Subscribers.First(a => a.ID == changes.id);
if (subscriber.Email != changes.email)
subscriber.Email = changes.email;
if (subscriber.FirstName != changes.firstName)
subscriber.FirstName = changes.firstName;
if (subscriber.LastName != changes lastName)
subscriber.LastName = changes lastName;
db.SaveChanges();
}*/
public void RemoveFromDatabase(SubscribeViewModel entry)
{
try
{
Subscriber subscriber = db.Subscribers.Find(entry.id);
db.Subscribers.Remove(subscriber);
db.SaveChanges();
}
catch (Exception e)
{
throw e;
}
}
public ActionResult Index(SubscribeViewModel model)
{
var subscriber = model.Get <SubscribeViewModel, SubscriberInfo>();
var isOk = queueProvider.Suscribe(subscriber);
model.SubscriptionIsOk = isOk;
model.UnSubscriptionIsOk = true;
if (isOk)
{
ViewBag.SubscribeMsg =
"your subscription will proccess soon & you will get informed throgh given email address";
}
return(View(model));
}
public static Subscribe MapEntity(this SubscribeViewModel model, IMapper mapper, string currentUserId)
{
var entity = mapper.Map <SubscribeViewModel, Subscribe>(model);
entity.StartDate = model.StartDateText.ToStartDate();
entity.EndDate = model.EndDateText.ToStartDate();
if (model.Id == 0)
{
entity.SetCreated(currentUserId);
}
entity.SetUpdated(currentUserId);
return(entity);
}
public IActionResult Subscribe(SubscribeViewModel model)
{
if (ModelState.IsValid)
{
Subscribe newSubscribe = new Subscribe {
BookId = model.BookId, Email = model.Email
};
if (dbContext.Subscribes.Where(s => s.Email == newSubscribe.Email).Count() == 0)
{
dbContext.Subscribes.Add(newSubscribe);
dbContext.SaveChanges();
}
}
return(RedirectToAction("Index"));
}
public ActionResult Delete(int id, SubscribeViewModel vm)
{
try
{
int currentUserId = GetCurrentUserProfileId();
vm.SubscriberUserId = currentUserId;
Subscription sub = _subRepo.GetSubscription(vm);
_subRepo.Delete(sub);
return(RedirectToAction("Details", "Post", new { id = vm.PostId }));
}
catch
{
return(View(vm));
}
}
[HttpPost]//object initilaization syntax
//maps viewmodel to actualy database model.
public ActionResult Subscribe(SubscribeViewModel sub)
{
if (ModelState.IsValid)
{
Subscriber s = new Subscriber()
{
FirstName = sub.FirstName,
Lastname = sub.Lastname,
EmailAddress = sub.EmailAddress
};
SubscribeDB.Subsribe(s);
return(RedirectToAction("Index", "Home"));
}
//return model back to page with errors
return(View(sub));
}
public ActionResult UnSubscribe(SubscribeViewModel model)
{
var unsubscriber = new UnSubscriberInfo()
{
EmailAddress = model.UnSubscribeEmailAddress
};
var isOk = queueProvider.Unsubscribe(unsubscriber);
model.SubscriptionIsOk = true;
model.UnSubscriptionIsOk = isOk;
if (isOk)
{
ViewBag.UnsubscribeMsg =
"for unsubscribing, a confrimation request will be sent to given address";
}
return(View("Index", model));
}
public IActionResult Unsubscribe([FromBody] SubscribeViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
_userRepository.Unsubscribe(viewModel.UserId, viewModel.EstablishmentId);
return(Ok());
}
catch (AuthenticationException e)
{
return(BadRequest(new { message = e.Message }));
}
}
public bool Subscribe(SubscribeViewModel subscribeViewModel)
{
Throw.IfNull(subscribeViewModel, nameof(subscribeViewModel));
Throw.IfNull(subscribeViewModel.Email, nameof(subscribeViewModel.Email));
List <string> tags;
if (Context.User.Profile.Email == subscribeViewModel.Email)
{
var propertyValue = Context.User.Profile.GetCustomProperty(Tags);
tags = string.IsNullOrWhiteSpace(propertyValue)
? new List <string>()
: Newtonsoft.Json.JsonConvert.DeserializeObject <List <string> >(propertyValue);
}
else
{
tags = _tagsRepository.GetAll(EventTag.TemplateId).Select(i => i.TagName).ToList();
}
var subscriber = _subscribersRepository
.Get(i => i.Email == subscribeViewModel.Email);
if (subscriber == null)
{
_subscribersRepository.Create(new Subscriber
{
Email = subscribeViewModel.Email,
Tags = tags
});
_logger.Info($"Created new subscriber {subscribeViewModel.Email}");
}
else
{
if (!subscriber.IsSubscribed)
{
_subscribersRepository.UpdateField(subscriber.Id, i => i.IsSubscribed, true);
_logger.Info($"User {subscribeViewModel.Email} subscribed again");
}
_subscribersRepository.UpdateField(subscriber.Id, i => i.Tags, tags);
}
return(true);
}
public ActionResult Index(int id, SubscribeViewModel vm)
{
try
{
int currentUserId = GetCurrentUserProfileId();
Subscription sub = new Subscription()
{
SubscriberUserProfileId = currentUserId,
ProviderUserProfileId = vm.ProviderUserId
};
_subRepo.Add(sub);
return(RedirectToAction("Details", "Post", new { id = vm.PostId }));
}
catch
{
return(View(vm));
}
}
public async Task <SubscribeViewModel> GetSubscribeViewModel(Course course, string currentUserId)
{
var vm = new SubscribeViewModel();
var workDays = new List <DayOfWeek>();
foreach (var item in course.WeekPlans.OrderBy(x => x.WeekDay))
{
workDays.Add(item.WeekDay);
}
vm.WorkDays = workDays;
vm.Lessons = new FormingScheduleService().GetAvalibleLessons(await _userService.GetUserWithLessonsList(currentUserId), course, currentUserId);
// vm.Lessons = new FormingScheduleService().GetAvalibleLessonsForTeacher(context, course, currentUserId);
vm.Course = course;
return(vm);
}
protected virtual PartialViewResult Index(Guid activityId, Subscribe subscriber, Enum type = null)
{
var model = new SubscribeViewModel
{
Id = subscriber?.Id,
UserId = _intranetMemberService.GetCurrentMemberId(),
ActivityId = activityId,
IsSubscribed = subscriber != null,
IsNotificationDisabled = subscriber?.IsNotificationDisabled ?? false
};
if (type != null)
{
model.HasNotification = _subscribeService.HasNotification(type);
}
return(PartialView(IndexViewPath, model));
}
public async Task <SubscriptionViewModel> Subscribe(SubscribeViewModel subscribeViewModel, WebSubSubscriber webSubSubscriber)
{
if (!ModelState.IsValid)
{
return(new SubscriptionViewModel(ModelState));
}
WebSubSubscription webSubSubscription = null;
try
{
webSubSubscription = await _webSubSubscriptionsStore.CreateAsync();
webSubSubscription.CallbackUrl = Request.GetWebSubWebHookUrl(webSubSubscription.Id);
WebSubSubscribeParameters webSubSubscribeParameters = new WebSubSubscribeParameters(subscribeViewModel.Url, webSubSubscription.CallbackUrl)
{
OnDiscoveredAsync = async(WebSubDiscoveredUrls discovery, CancellationToken cancellationToken) =>
{
webSubSubscription.State = WebSubSubscriptionState.SubscribeRequested;
webSubSubscription.TopicUrl = discovery.Topic;
await _webSubSubscriptionsStore.UpdateAsync(webSubSubscription);
}
};
if (!String.IsNullOrWhiteSpace(subscribeViewModel.Secret))
{
webSubSubscription.Secret = subscribeViewModel.Secret;
webSubSubscribeParameters.Secret = subscribeViewModel.Secret;
}
webSubSubscription.HubUrl = (await webSubSubscriber.SubscribeAsync(webSubSubscribeParameters, HttpContext.RequestAborted)).Hub;
return(new SubscriptionViewModel(webSubSubscription));
}
catch (Exception ex) when((ex is WebSubDiscoveryException) || (ex is WebSubSubscriptionException))
{
await _webSubSubscriptionsStore.RemoveAsync(webSubSubscription);
return(new SubscriptionViewModel(ex));
}
}
public SubscribeViewModel GetSubscribeViewModel(Course course, ApplicationDbContext context, string currentUserId)
{
var vm = new SubscribeViewModel();
var workDays = new List <DayOfWeek>();
foreach (var item in course.WeekPlans.OrderBy(x => x.WeekDay))
{
workDays.Add(item.WeekDay);
}
vm.WorkDays = workDays;
vm.Lessons = new FormingScheduleService().GetAvalibleLessons(context, course, currentUserId);
// vm.Lessons = new FormingScheduleService().GetAvalibleLessonsForTeacher(context, course, currentUserId);
vm.Course = course;
vm.LessonNumber = course.LessonsNumber;
return(vm);
}
public JsonResult Subscription(
SubscribeViewModel subscribeViewModel,
SubscriptionValidator subscriptionValidator)
{
Throw.IfNull(subscribeViewModel, nameof(subscribeViewModel));
Throw.IfNull(subscriptionValidator, nameof(subscriptionValidator));
subscriptionValidator.SetMessageToEmailValidator(subscribeViewModel.EmailValidationMessage);
var modelState = subscriptionValidator.Validate(subscribeViewModel);
var success = false;
var validationMessages = modelState.Errors.FirstOrDefault()?.ErrorMessage;
if (modelState.IsValid)
{
success = _mailingService.Subscribe(subscribeViewModel);
}
return(Json(new { success, validationMessages }));
}
