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