public GamesController(HeaderController headerController)
{
_HeaderController = headerController;
Entities.GameContext _context = new Entities.GameContext();
_NGSubscriptionsEntities = new NGSubscriptionsEntities();
subscriberRepository = new SubscriberRepository(_context, _NGSubscriptionsEntities);
}
public UnitOfWork(StoreContext storeContext, IUserRepository userRepository, ICommentRepository commentRepository,
CategoryRepository categoryRepository, ImageRepository imageRepository,
ProductCharacteristicRepository productCharacteristicRepository,
CharacteristicRepository characteristicRepository, ProductRepository productRepository,
DeliveryRepository deliveryRepository, AddressRepository addressRepository, BrandRepository brandRepository,
OrderDetailsRepository orderDetailsRepository, OrderRepository orderRepository,
PackageRepository packageRepository, ILikeRepository likeRepository, NewsRepository newsRepository,
SubscriberRepository subscriberRepository)
{
_storeContext = storeContext;
UserRepository = userRepository;
CommentRepository = commentRepository;
CategoryRepository = categoryRepository;
ImageRepository = imageRepository;
ProductCharacteristicRepository = productCharacteristicRepository;
CharacteristicRepository = characteristicRepository;
ProductRepository = productRepository;
DeliveryRepository = deliveryRepository;
AddressRepository = addressRepository;
BrandRepository = brandRepository;
OrderDetailsRepository = orderDetailsRepository;
OrderRepository = orderRepository;
PackageRepository = packageRepository;
LikeRepository = likeRepository;
NewsRepository = newsRepository;
SubscriberRepository = subscriberRepository;
}
public async Task <IActionResult> Add([FromBody] SubscribeRequest request)
{
var result = false;
try
{
_log.LogEntrance(nameof(Add), request.ToString());
var repository = new SubscriberRepository(_log, false);
var newSubscriber = new Subscriber(request.FirstName, request.EMail);
await repository.AddAsync(newSubscriber);
result = true;
return(Ok(result));
}
catch (Exception ex)
{
_log.LogError($"my exception : [{ex.Message}] [{ex.StackTrace}]");
return(Ok(false));
}
finally
{
_log.LogExit(nameof(Add), result.ToString());
}
}
public async Task <IActionResult> ListSubscribers(string passcode)
{
var result = new List <Subscriber>();
try
{
if (passcode == "simurghi")
{
_log.LogEntrance(nameof(ListSubscribers), passcode.ToString());
var repository = new SubscriberRepository(_log, false);
result = repository.GetAll().ToList();
return(Ok(result));
}
return(NotFound());
}
catch (Exception ex)
{
_log.LogError($"my exception : [{ex.Message}] [{ex.StackTrace}]");
return(NotFound(false));
}
finally
{
_log.LogExit(nameof(Add), result.ToString());
}
}
public async void SubscriberRepositoryTest()
{
var repo = new SubscriberRepository(_logger, false);
var firstSubscriber = new Subscriber("Amir", "*****@*****.**");
await repo.AddAsync(firstSubscriber);
var id = firstSubscriber.Id;
repo.Detach(firstSubscriber);
var secondSubscriber = new Subscriber("Amir", "*****@*****.**");
await Assert.ThrowsAsync <Microsoft.EntityFrameworkCore.DbUpdateException>(
() => repo.AddAsync(secondSubscriber)
);
Assert.Throws <Microsoft.EntityFrameworkCore.DbUpdateException>(
() => {
repo.Add(secondSubscriber);
});
//we should reconnect to see the deleted objects
repo = new SubscriberRepository(_logger, false);
repo.Delete(id);
var count = repo.GetAll().Count();
Assert.Equal(0, count);
}
protected void Page_Load(object sender, EventArgs e)
{
var repo = new SubscriberRepository();
gridSubscribers.DataSource = repo.GetAll();
gridSubscribers.DataBind();
}
public CourseController(SubscriberRepository subscriberRepository,
AuthorRepository authorRepository, CourseRepository courseRepository,
SubscriptionRepository subscriptionRepository, SubjectRepository subjectRepository)
{
this.authorRepository = authorRepository;
this.subscriberRepository = subscriberRepository;
this.courseRepository = courseRepository;
this.subscriptionRepository = subscriptionRepository;
this.subjectRepository = subjectRepository;
}
/// <summary>
/// people can subscribe to the newsletters without registering on the site. This method is used to attach those existing subscriptions to the user upon registration
/// </summary>
/// <param name="siteUser"></param>
public static void ClaimExistingSubscriptions(SiteUser siteUser)
{
SubscriberRepository subscriptions = new SubscriberRepository();
List <LetterSubscriber> userSubscriptions = subscriptions.GetListByEmail(siteUser.SiteGuid, siteUser.Email);
foreach (LetterSubscriber s in userSubscriptions)
{
if (s.UserGuid != siteUser.UserGuid)
{
s.UserGuid = siteUser.UserGuid;
subscriptions.Save(s);
}
if (!s.IsVerified)
{
subscriptions.Verify(s.SubscribeGuid, true, Guid.Empty);
LetterInfo.UpdateSubscriberCount(s.LetterInfoGuid);
}
}
List <LetterSubscriber> memberSubscriptions = subscriptions.GetListByUser(siteUser.SiteGuid, siteUser.UserGuid);
RemoveDuplicates(memberSubscriptions);
// commented out 2012-11-16 since we now give the user a chance to opt in the registration
// then we should not force him in if he chose not to opt in
//if (memberSubscriptions.Count == 0)
//{
// string ipAddress = SiteUtils.GetIP4Address();
// //user has no previous subscriptions and just registered
// // lets give him the site subscriptions that are configured for opting in new users by default
// List<LetterInfo> allNewsletters = LetterInfo.GetAll(siteUser.SiteGuid);
// foreach (LetterInfo l in allNewsletters)
// {
// if ((l.ProfileOptIn) && (l.AvailableToRoles.Contains("All Users;")))
// {
// LetterSubscriber s = new LetterSubscriber();
// s.SiteGuid = siteUser.SiteGuid;
// s.LetterInfoGuid = l.LetterInfoGuid;
// s.UserGuid = siteUser.UserGuid;
// s.EmailAddress = siteUser.Email;
// s.IsVerified = true;
// s.UseHtml = true;
// s.IpAddress = ipAddress;
// subscriptions.Save(s);
// }
// }
//}
}
public UnitOfWork(
BlogContext context,
IMapper mapper)
{
this._context = context;
Blogs = new BlogRepository(context, mapper);
Tags = new TagRepository(context);
Blobs = new BlobRepository(context, mapper);
Subscribers = new SubscriberRepository(context, mapper);
}
private void RunTask()
{
// this is where the work gets done
// Get a data table of up to 1000 users
// who have not opted in but also have not previously
// opted out and have valid email accounts and account is not locked
DataTable dataTable = GetData();
double completeRatio = .5;
if (dataTable.Rows.Count == 0)
{
completeRatio = 1; //complete
ReportStatus(completeRatio);
return;
}
SubscriberRepository repository = new SubscriberRepository();
int count = 0;
foreach (DataRow row in dataTable.Rows)
{
Guid userGuid = new Guid(row["UserGuid"].ToString());
string email = row["email"].ToString();
LetterSubscriber s = new LetterSubscriber();
s.SiteGuid = SiteGuid;
s.UserGuid = userGuid;
s.EmailAddress = email;
s.LetterInfoGuid = LetterInfoGuid;
s.UseHtml = true;
s.IsVerified = true;
repository.Save(s);
count += 1;
if (count > 20)
{
ReportStatus(completeRatio);
count = 0;
}
}
LetterInfo.UpdateSubscriberCount(LetterInfoGuid);
ReportStatus(completeRatio);
// repeat until the table comes back with 0 rows
RunTask();
}
public static void VerifyExistingSubscriptions(SiteUser siteUser)
{
SubscriberRepository subscriptions = new SubscriberRepository();
List <LetterSubscriber> userSubscriptions = subscriptions.GetListByUser(siteUser.SiteGuid, siteUser.UserGuid);
foreach (LetterSubscriber s in userSubscriptions)
{
if (!s.IsVerified)
{
subscriptions.Verify(s.SubscribeGuid, true, Guid.Empty);
LetterInfo.UpdateSubscriberCount(s.LetterInfoGuid);
}
}
}
public static bool DeleteSubscriber(int id)
{
try
{
var repo = new SubscriberRepository();
repo.Delete(id);
return(true);
}
catch (LocalException ex)
{
}
return(false);
}
public IHttpActionResult GetByTel(string tell)
{
var subscriber = new SubscriberRepository();
var s = subscriber.GetUserByPhoneNo(tell);
if (s == null)
{
return(ResponseMessage(Request.CreateResponse(new ResponseStatus()
{
status = HttpStatusCode.NotFound, message = "You do not have a valid subscription"
})));
}
return(Ok(new ResponseStatus()
{
status = HttpStatusCode.OK, message = "Valid User"
}));
}
static void Main()
{
var connectionString = "Data Source = LUNA\\SQLEXPRESS; Initial Catalog = Library; Integrated Security = True";
IBookRepository bookRepository = new BookRepository(new BookContext(connectionString));
ILibrarianRepository librarianRepository = new LibrarianRepository(new LibrarianContext(connectionString));
ISubscriberRepository subscriberRepository = new SubscriberRepository(new SubscriberContext(connectionString));
IBorrowedBookRepository borrowedBookRepository = new BorrowedBookRepository(new BorrowedBookContext(connectionString));
IReservedBookRepository reservedBookRepository = new ReservedBookRepository(new ReservedBookContext(connectionString));
IReturnedBookRepository returnedBookRepository = new ReturnedBookRepository(new ReturnedBookContext(connectionString));
IService service = new Service.Service(bookRepository, librarianRepository, subscriberRepository, borrowedBookRepository, reservedBookRepository, returnedBookRepository);
Application.SetHighDpiMode(HighDpiMode.SystemAware);
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new LogInForm(service));
}
/// <summary>
/// people can subscribe to the newsletters without registering on the site. This method is used to attach those existing subscriptions to the user upon registration
/// </summary>
/// <param name="siteUser"></param>
public static void ClaimExistingSubscriptions(SiteUser siteUser)
{
SubscriberRepository subscriptions = new SubscriberRepository();
List <LetterSubscriber> userSubscriptions = subscriptions.GetListByEmail(siteUser.SiteGuid, siteUser.Email);
foreach (LetterSubscriber s in userSubscriptions)
{
if (s.UserGuid != siteUser.UserGuid)
{
s.UserGuid = siteUser.UserGuid;
subscriptions.Save(s);
}
if (!s.IsVerified)
{
subscriptions.Verify(s.SubscribeGuid, true, Guid.Empty);
LetterInfo.UpdateSubscriberCount(s.LetterInfoGuid);
}
}
RemoveDuplicates(userSubscriptions);
if (userSubscriptions.Count == 0)
{
string ipAddress = SiteUtils.GetIP4Address();
//user has no previous subscriptions and just registered
// lets give him the site subscriptions that are configured for opting in new users by default
List <LetterInfo> allNewsletters = LetterInfo.GetAll(siteUser.SiteGuid);
foreach (LetterInfo l in allNewsletters)
{
if ((l.ProfileOptIn) && (l.AvailableToRoles.Contains("All Users;")))
{
LetterSubscriber s = new LetterSubscriber();
s.SiteGuid = siteUser.SiteGuid;
s.LetterInfoGuid = l.LetterInfoGuid;
s.UserGuid = siteUser.UserGuid;
s.EmailAddress = siteUser.Email;
s.IsVerified = true;
s.UseHtml = true;
s.IpAddress = ipAddress;
subscriptions.Save(s);
}
}
}
}
private void PopulateControls()
{
if (letterInfoGuid == Guid.Empty)
{
btnOptInUsers.Visible = false;
return;
}
letterInfo = new LetterInfo(letterInfoGuid);
heading.Text = letterInfo.Title;
countOfAvailableUsers = SubscriberRepository.CountUsersNotSubscribedByLetter(
CurrentSite.SiteGuid,
letterInfoGuid,
WebConfigSettings.NewsletterExcludeAllPreviousOptOutsWhenOptingInUsers);
btnOptInUsers.Text = string.Format(CultureInfo.InvariantCulture, Resource.NewsLetterOptInMembersFormat, countOfAvailableUsers);
}
protected void btnSendToSubscribers_Click(object sender, EventArgs e)
{
if (RadEditor1.Content == string.Empty)
{
((AdminPanel)Master).GeneralMessage = "متن مطلب خالی است";
((AdminPanel)Master).MessageType = MessageType.Error;
return;
}
SubscriberRepository repo = new SubscriberRepository();
IList <Subscriber> subscribers = repo.GetAll();
foreach (Subscriber subscriber in subscribers)
{
Utility.SendEmail("*****@*****.**", subscriber.EMail, RadEditor1.Text, "تیارا الکتریک",
"atc@8873");
}
}
private void SaveNewSubscriber(string email)
{
var s = new SubscriberRepository().GetByEmail(email);
if (s == null)
{
s = new Subscriber();
s.Email = email;
s.DateCreated = DateTime.Now;
s.IsActive = true;
new SubscriberRepository().Save(s);
var t = new CampaignManager.Core.Domain.SubscriberCampaignTag();
t.CampaignTagID = Convert.ToInt16(ConfigurationManager.AppSettings["ALLSUBSCRIBERSTAGID"]);
t.SubscriberID = s.ID;
new CampaignManager.Data.Repositories.SubscriberCampaignTagRepository().Save(t);
}
}
private IXDListener CreateNetworkListener(IIdentityProvider provider)
{
var settings = AmazonAccountSettings.GetInstance();
var amazonSnsFacade = new AmazonSnsFacade(settings);
var amazonSqsFacade = new AmazonSqsFacade(settings);
var queuePoller = new QueuePoller(amazonSqsFacade);
var resourceCounter = new ResourceCounter();
var respository = new TopicRepository(AmazonAccountSettings.GetInstance(), amazonSnsFacade);
var subscriberRepository = new SubscriberRepository(settings, amazonSqsFacade);
var subscriptionService = new SubscriptionService(
resourceCounter,
amazonSnsFacade,
amazonSqsFacade,
subscriberRepository,
queuePoller);
return(new XDAmazonListener(provider, serializer, respository, subscriberRepository, subscriptionService));
}
public async Task<ActionResult> Subscribe(Subscriber subscriber)
{
try
{
var subscriberRepo = new SubscriberRepository();
subscriberRepo.Create(new Subscriber
{
Email = subscriber.Email,
DateRegistered = DateTime.UtcNow
});
return Json(new { success = true, responseText = "Added." }, JsonRequestBehavior.AllowGet);
}
catch (Exception ex)
{
Response.StatusCode = (int)HttpStatusCode.InternalServerError;
return Json(new { success = false, responseText = ex.Message }, JsonRequestBehavior.AllowGet);
}
}
protected override async Task ProtectedProcess(CMMNExecutionContext executionContext, TimerEventListener elt, CancellationToken cancellationToken)
{
if (elt.NbOccurrence == 0)
{
var subExists = (await SubscriberRepository.Get(executionContext.CasePlanInstance.AggregateId, elt.Id, CMMNConstants.ExternalTransitionNames.Occur, cancellationToken) != null);
if (!subExists)
{
await Init(executionContext, elt, cancellationToken);
return;
}
}
var subscription = await TrySubscribe(executionContext, elt, CMMNConstants.ExternalTransitionNames.Occur, cancellationToken);
if (subscription.IsCaptured)
{
executionContext.CasePlanInstance.MakeTransition(elt, CMMNTransitions.Occur);
}
}
public async Task <ActionResult> Subscribe(Subscriber subscriber)
{
try
{
var subscriberRepo = new SubscriberRepository();
subscriberRepo.Create(new Subscriber
{
Email = subscriber.Email,
DateRegistered = DateTime.UtcNow
});
return(Json(new { success = true, responseText = "Added." }, JsonRequestBehavior.AllowGet));
}
catch (Exception ex)
{
Response.StatusCode = (int)HttpStatusCode.InternalServerError;
return(Json(new { success = false, responseText = ex.Message }, JsonRequestBehavior.AllowGet));
}
}
public IHttpActionResult Get(string token)
{
var subscriber = new SubscriberRepository();
var s = subscriber.GetUser(token);
if (s == null)
{
//return ResponseMessage(Request.CreateResponse(HttpStatusCode.NotFound, "You do not have a valid subscription"));
///return ResponseMessage(GetMessage("You do not have a valid subscription", HttpStatusCode.NotFound, 400));
return(ResponseMessage(Request.CreateResponse(new ResponseStatus()
{
status = HttpStatusCode.NotFound, message = "You do not have a valid subscription"
})));
}
//return ResponseMessage(GetMessage("Valid User", HttpStatusCode.OK, 200));
return(Ok(new ResponseStatus()
{
status = HttpStatusCode.OK, message = "Valid User"
}));
}
private void PopulateControls()
{
if (letterInfoGuid == Guid.Empty)
{
return;
}
letterInfo = new LetterInfo(letterInfoGuid);
lnkThisPage.Text = string.Format(CultureInfo.InvariantCulture,
Resource.NewsletterSubscriberListHeadingFormatString,
letterInfo.Title);
lnkThisPage.ToolTip = lnkThisPage.Text;
heading.Text = lnkThisPage.Text;
Title = heading.Text;
int countOfUsersThatCouldOptIn = SubscriberRepository.CountUsersNotSubscribedByLetter(
siteSettings.SiteGuid,
letterInfoGuid,
WebConfigSettings.NewsletterExcludeAllPreviousOptOutsWhenOptingInUsers);
if (countOfUsersThatCouldOptIn > 0)
{
lnkOptIn.Visible = true;
lnkOptIn.Text = string.Format(CultureInfo.InvariantCulture, Resource.NewsLetterOptInMembersFormat, countOfUsersThatCouldOptIn);
}
if (Page.IsPostBack)
{
return;
}
BindGrid();
}
protected override async Task ProtectedProcess(CMMNExecutionContext executionContext, CaseEltInstance elt, CancellationToken cancellationToken)
{
if (elt.NbOccurrence == 0)
{
var subExists = (await SubscriberRepository.Get(executionContext.Instance.AggregateId, elt.Id, CMMNConstants.ExternalTransitionNames.Occur, cancellationToken) != null);
if (!subExists)
{
await Init(executionContext, elt, cancellationToken);
return;
}
}
var subscription = await TrySubscribe(executionContext, elt, CMMNConstants.ExternalTransitionNames.Occur, cancellationToken);
if (subscription.IsCaptured)
{
var sub = await TryReset(executionContext, elt, CMMNConstants.ExternalTransitionNames.Occur, cancellationToken);
executionContext.Instance.MakeTransition(elt, CMMNTransitions.Occur, incomingTokens: MergeParameters(executionContext, sub.Parameters));
}
}
private static void RemoveDuplicates(List <LetterSubscriber> userSubscriptions)
{
SubscriberRepository subscriptions = new SubscriberRepository();
List <LetterSubscriber> cleanSubscriptions = new List <LetterSubscriber>();
List <LetterSubscriber> duplicates = new List <LetterSubscriber>();
foreach (LetterSubscriber s in userSubscriptions)
{
if (!ContainsSubscription(cleanSubscriptions, s.LetterInfoGuid))
{
cleanSubscriptions.Add(s);
}
else
{
duplicates.Add(s);
}
}
foreach (LetterSubscriber s in duplicates)
{
subscriptions.Delete(s, false);
}
}
public SubscriberRepositoryTests()
{
subscriberRepository = new SubscriberRepository();
}
private void RunTask()
{
Letter letter = new Letter(this.letterGuid);
if (letter.LetterGuid == Guid.Empty)
{
log.Error("LetterSendTask letter not found so ending.");
ReportStatus();
return;
}
if (letter.SendCompleteUtc > DateTime.MinValue)
{
log.Error("LetterSendTask SendCompleteUtc already set so ending.");
ReportStatus();
return;
}
if (letter.SendClickedUtc == DateTime.MinValue)
{
log.Error("LetterSendTask SendClickedUtc has an invalid value so ending.");
ReportStatus();
return;
}
LetterInfo letterInfo = new LetterInfo(letter.LetterInfoGuid);
SubscriberRepository subscriptions = new SubscriberRepository();
if (
(ConfigurationManager.AppSettings["NewsletterTestMode"] != null) &&
(ConfigurationManager.AppSettings["NewsletterTestMode"] == "true")
)
{
testMode = true;
log.Info("using NewsletterTestMode=true in config so no real emails will be sent for newsletter " + letterInfo.Title);
}
// TODO: this could be a very large recordset if the list is very large
// might be better to get a page at a time instead of all at once.
List <LetterSubscriber> subscribers
= subscriptions.GetSubscribersNotSentYet(
letter.LetterGuid,
letter.LetterInfoGuid);
nextStatusUpdateTime = DateTime.UtcNow.AddSeconds(updateFrequency);
totalSubscribersToSend = subscribers.Count;
if ((totalSubscribersToSend > 0) && (letter.SendStartedUtc == DateTime.MinValue))
{
letter.TrackSendStarted();
}
if (totalSubscribersToSend < 100)
{
testSleepMilliseconds = 3000;
}
if (totalSubscribersToSend > 300)
{
testSleepMilliseconds = 500;
}
if (totalSubscribersToSend > 500)
{
testSleepMilliseconds = 100;
}
SmtpSettings smtpSettings = new SmtpSettings();
smtpSettings.Password = password;
smtpSettings.Port = port;
smtpSettings.PreferredEncoding = preferredEncoding;
smtpSettings.RequiresAuthentication = requiresAuthentication;
smtpSettings.UseSsl = useSsl;
smtpSettings.User = user;
smtpSettings.Server = server;
foreach (LetterSubscriber subscriber in subscribers)
{
SendLetter(smtpSettings, letterInfo, letter, subscriber);
subscribersSentSoFar += 1;
if (DateTime.UtcNow > nextStatusUpdateTime)
{
ReportStatus();
}
}
ReportStatus();
}
public EventServerRepository()
{
_ctx = new EventContext();
Events = new EventRepository(_ctx);
Subscribers = new SubscriberRepository(_ctx);
}
public UserController(SubscriberRepository subscriberRepository,
AuthorRepository authorRepository)
{
this.authorRepository = authorRepository;
this.subscriberRepository = subscriberRepository;
}
public SubscriberRepositoryTests()
{
m_Handler = new TestActionHandler();
m_Sut = new SubscriberRepository();
}
private DataTable GetData()
{
return(SubscriberRepository.GetTop1000UsersNotSubscribed(siteGuid, letterInfoGuid, excludeIfAnyUnsubscribeHx));
}
