def create(cls,
user_name,
email,
password=None,
locale=None,
openid_identity=None,
global_admin=False,
display_name=None):
from group import Group
from membership import Membership
from openid import OpenID
import adhocracy.lib.util as util
if password is None:
password = util.random_token()
import adhocracy.i18n as i18n
if locale is None:
locale = i18n.get_default_locale()
user = User(user_name,
email,
password,
locale,
display_name=display_name)
meta.Session.add(user)
# Add the global default group
default_group = Group.by_code(Group.CODE_DEFAULT)
default_membership = Membership(user, None, default_group)
meta.Session.add(default_membership)
# Autojoin the user in instances
config_autojoin = config.get('adhocracy.instances.autojoin')
if config_autojoin:
instances = Instance.all()
if config_autojoin != 'ALL':
instance_keys = [
key.strip() for key in config_autojoin.split(",")
]
instances = [
instance for instance in instances
if instance.key in instance_keys
]
for instance in instances:
autojoin_membership = Membership(user, instance,
instance.default_group)
meta.Session.add(autojoin_membership)
if global_admin:
admin_group = Group.by_code(Group.CODE_ADMIN)
admin_membership = Membership(user, None, admin_group)
meta.Session.add(admin_membership)
if openid_identity is not None:
openid = OpenID(unicode(openid_identity), user)
meta.Session.add(openid)
meta.Session.flush()
return user
def create(cls, key, label, user, description=None, locale=None):
from group import Group
from membership import Membership
from page import Page
instance = Instance(unicode(key).lower(), label, user)
instance.description = description
instance.default_group = Group.by_code(Group.INSTANCE_DEFAULT)
if locale is not None:
instance.locale = locale
meta.Session.add(instance)
supervisor_group = Group.by_code(Group.CODE_SUPERVISOR)
membership = Membership(user, instance, supervisor_group,
approved=True)
meta.Session.add(membership)
if config.get_bool('adhocracy.create_initial_instance_page'):
Page.create(instance, label, u"", user)
# Autojoin the user in instances
config_autojoin = config.get('adhocracy.instances.autojoin')
if (config_autojoin and
(config_autojoin == 'ALL' or
key in (k.strip() for k in config_autojoin.split(',')))):
users = adhocracy.model.User.all()
for u in users:
autojoin_membership = Membership(u, instance,
instance.default_group)
meta.Session.add(autojoin_membership)
meta.Session.flush()
return instance
def test_legacy_pairing(self):
self.plan1.member_limit = 2
user1 = Membership(first_name="Testy1",
last_name="Testerson",
email="*****@*****.**",
plan="plan1")
user1.put()
user2 = Membership(first_name="Testy2",
last_name="Testerson",
email="*****@*****.**",
plan="plan4")
user2.put()
self.assertTrue(self.plan1.is_full())
def unidirectional_network(redditor: str,
reddit_interactions: DataFrame) -> nx.Graph:
''' Construct unidirectional reddit reply network. Edge exists between two users if either has
interacted with the other (A replied to B, B replied to A, or A replied to B and B replied to A.
'''
G = nx.Graph(user=redditor)
for index, row in reddit_interactions.iterrows():
author = row['author']
subreddit = row['subreddit']
date = row['date'].to_pydatetime()
replying_to = row['replyingTo']
polarity = row['polarity']
subjectivity = row['subjectivity']
reply_count = int(row['replyCount'])
# Node
if not G.has_node(author):
G.add_node(author, membership=Membership())
elif not 'membership' in G.node[author]:
G.node[author]['membership'] = Membership()
G.node[author]['membership'].append(subreddit, date)
# Edge
# If not replying to anyone (submission is used in membership attribute but not relationship attribute)
if replying_to is None:
continue
# Don't put self loops in graph
if replying_to == author:
continue
# If edge is new: add edge to graph and construct Relationship object
if not G.has_edge(author, replying_to):
G.add_edge(author, replying_to, relationship=Relationship())
# Append comment data to Relationship attribute of edge
G[author][replying_to]['relationship'].append(author, replying_to,
subreddit, date,
polarity, subjectivity,
reply_count)
# Remove nodes on periphery of network (not connected to central user)
G.remove_nodes_from([
user for user, membership in G.nodes(data='membership')
if membership is None
])
return G
def post(self):
if Config().is_dev:
# Only allow this if it's the dev server.
entry = self.request.body
logging.debug("Got new entry: " + entry)
entry = json.loads(entry)
# Change formatted date back into datetime.
for key in entry.keys():
if type(getattr(Membership, key)) == db.DateTimeProperty:
if not entry[key]:
# It could be None as well.
continue
entry[key] = pickle.loads(str(entry[key]))
# entry should have everything nicely in a dict...
member = Membership(**entry)
# Is this an update or a new model?
match = Membership.all().filter("email =", member.email).get()
if match:
# Replace the old one.
logging.debug("Found entry with same username. Replacing...")
db.delete(match)
member.put()
logging.debug("Put entry in datastore.")
def setUp(self):
# Set up testing for application.
self.test_app = webtest.TestApp(user_api.app)
# Set up datastore for testing.
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub()
# Create a new plan for testing.
Plan.all_plans = []
self.test_plan = Plan("test",
1,
100,
"A test plan.",
signin_limit=Config().LITE_VISITS)
# Add a user to the datastore.
self.user = Membership(first_name="Daniel",
last_name="Petti",
email="*****@*****.**",
plan="test",
username="******",
status="active")
self.user.put()
def adduser(self,
connection,
user: User,
isop: bool = False,
ishop: bool = False,
isvoice: bool = False,
isadmin: bool = False):
"""
Adds a user to a channel, if the user exists in our list
:param user:
:param connection:
:param isop: bool, sets whether the user is opped in the channel
:param ishop: bool, sets whether the user is hopped in the channel
:param isvoice: bool, sets whether the user is voiced in the channel
:param isadmin: bool, sets whether the user is marked as an admin
in the channel
:return: Membership, the membership object created
"""
if user.nick in connection.users:
temp = Membership(self,
user,
isop=isop,
ishop=ishop,
isvoice=isvoice,
isadmin=isadmin)
self.memberships[user.nick] = temp
user.memberships[self.name] = temp
return temp
else:
raise ValueError("Unknown User")
def test_signin_limit(self):
self.plan1.signin_limit = 2
user = Membership(first_name="Testy",
last_name="Testerson",
email="*****@*****.**",
plan="plan1")
user.put()
# We should have all 2 signins left.
self.assertEqual(2, Plan.signins_remaining(user))
# Signin once.
user.signins = 1
user.put()
self.assertEqual(1, Plan.signins_remaining(user))
# Signin again.
user.signins = 2
user.put()
self.assertEqual(0, Plan.signins_remaining(user))
# Should never be less than zero.
user.signins = 3
user.put()
self.assertEqual(0, Plan.signins_remaining(user))
# Give ourselves unlimited signins!
self.plan1.signin_limit = None
self.assertEqual(None, Plan.signins_remaining(user))
def setUp(self):
# Set up testing for application.
self.test_app = webtest.TestApp(billing.app)
# Set up datastore for testing.
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub()
self.testbed.init_user_stub()
# Make some testing plans.
self.test_plan = plans.Plan("test", 0, 150, "This is a test plan.")
self.test_plan_legacy = plans.Plan("test_legacy", 1, 100,
"This is a test plan.",
legacy=self.test_plan)
# Make a test user.
self.user = Membership(email="*****@*****.**",
first_name="Testy", last_name="Testerson",
username="******",
spreedly_token="notatoken", plan="test")
self.user.put()
# Simulate the user login.
self.testbed.setup_env(user_email=self.user.email, user_is_admin="0",
overwrite=True)
def processgossipsfromothernodemessage(self, othernodemessage, heartbeat,
lamporttime):
print '\n**********other list*********\n'
print othernodemessage.membershiplist
print '\n********self list***********\n'
print self
for nodeaddr in othernodemessage.membershiplist.membershiplist.keys():
print nodeaddr, self.has(
nodeaddr
), othernodemessage.membershiplist.membershiplist[nodeaddr]
othernodemembership = othernodemessage.membershiplist.membershiplist[
nodeaddr]
if self.has(nodeaddr):
# verify time before adding
print
else:
self.toupdatestatusfor(othernodemembership)
print '\n*************after adding missing members**************\n'
print self
#include self message with my heartbeat
newmembership = Membership(othernodemessage.fromaddr, heartbeat,
lamporttime, Membership.livestatus)
self.toupdatestatusfor(newmembership)
def __init__(self, attributes):
self.name = attributes.get('name')
self.cpf = attributes.get('name')
self.billingAddress = Address(attributes.get('billingAddress'))
if (attributes.get('membership') != None):
self.membership = Membership(attributes.get('membership'))
def setUp(self):
super(ReactivatePlanHandlerTest, self).setUp()
# Add a user to test with.
self.user = Membership(first_name="Testy",
last_name="Testerson",
email="*****@*****.**",
plan="plan1",
spreedly_token="notatoken",
hash="notahash",
username="******")
self.user.put()
def test_member_limit(self):
self.plan1.member_limit = 2
# Put some people in the datastore.
user1 = Membership(first_name="Testy1",
last_name="Testerson",
email="*****@*****.**",
plan="plan1")
user2 = Membership(first_name="Testy2",
last_name="Testerson",
email="*****@*****.**",
plan="plan1")
# The plan should not be full initially.
self.assertFalse(self.plan1.is_full())
# Adding one user should still not make it full.
user1.put()
self.assertFalse(self.plan1.is_full())
# Adding the other user should make it full.
user2.put()
self.assertTrue(self.plan1.is_full())
def setUp(self):
# Set up testing application.
self.test_app = webtest.TestApp(cron.app)
# Set up datastore for testing.
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub()
# Add a user to the datastore.
self.user = Membership(first_name="Testy",
last_name="Testerson",
email="*****@*****.**")
self.user.put()
def create(cls,
user_name,
email,
password=None,
locale=None,
openid_identity=None,
global_admin=False):
from group import Group
from membership import Membership
from openid import OpenID
import adhocracy.lib.util as util
if password is None:
password = util.random_token()
import adhocracy.i18n as i18n
if locale is None:
locale = i18n.get_default_locale()
user = User(user_name, email, password, locale)
meta.Session.add(user)
default_group = Group.by_code(Group.CODE_DEFAULT)
default_membership = Membership(user, None, default_group)
meta.Session.add(default_membership)
if global_admin:
admin_group = Group.by_code(Group.CODE_ADMIN)
admin_membership = Membership(user, None, admin_group)
meta.Session.add(admin_membership)
if openid_identity is not None:
openid = OpenID(unicode(openid_identity), user)
meta.Session.add(openid)
meta.Session.flush()
return user
def test_already_existing(self):
# Make a user in the datastore with the same email, but a different name so
# we can see whether it overrides.
existing_user = Membership(first_name="Michael",
last_name="Scarn",
email=self._TEST_PARAMS["email"],
status="active")
existing_user.put()
# Because the user is active, it should prohibit us from overriding.
response = self.test_app.post("/",
self._TEST_PARAMS,
expect_errors=True)
self.assertEqual(422, response.status_int)
self.assertIn("already exists", response.body)
# User should stay the same.
user = Membership.get_by_email(self._TEST_PARAMS["email"])
self.assertEqual("Michael", user.first_name)
self.assertEqual("Scarn", user.last_name)
existing_user.status = "suspended"
existing_user.put()
# Even though the user is suspended, it should still prohibit us from
# overriding.
response = self.test_app.post("/",
self._TEST_PARAMS,
expect_errors=True)
self.assertEqual(422, response.status_int)
self.assertIn("suspended", response.body)
# User should stay the same.
user = Membership.get_by_email(self._TEST_PARAMS["email"])
self.assertEqual("Michael", user.first_name)
self.assertEqual("Scarn", user.last_name)
existing_user.status = None
existing_user.put()
# Now the user should get silently overriden.
response = self.test_app.post("/", self._TEST_PARAMS)
self.assertEqual(302, response.status_int)
# User should not stay the same.
user = Membership.get_by_email(self._TEST_PARAMS["email"])
self.assertEqual(self._TEST_PARAMS["first_name"], user.first_name)
self.assertEqual(self._TEST_PARAMS["last_name"], user.last_name)
def setUp(self):
super(ChangePlanHandlerTest, self).setUp()
# Add a user to test with.
self.user = Membership(first_name="Testy",
last_name="Testerson",
email="*****@*****.**",
plan="plan1",
spreedly_token="notatoken",
username="******")
self.user.put()
# Login our test user.
self.testbed.init_user_stub()
self.testbed.setup_env(user_email="*****@*****.**",
overwrite=True)
def create(cls, key, label, user, description=None, locale=None):
from group import Group
from membership import Membership
from page import Page
instance = Instance(unicode(key).lower(), label, user)
instance.description = description
instance.default_group = Group.by_code(Group.INSTANCE_DEFAULT)
if locale is not None:
instance.locale = locale
meta.Session.add(instance)
supervisor_group = Group.by_code(Group.CODE_SUPERVISOR)
membership = Membership(user, instance, supervisor_group,
approved=True)
meta.Session.add(membership)
Page.create(instance, label, u"", user)
meta.Session.flush()
return instance
def test_skip_if_account(self):
plan = Plan("test", 0, 100, "This is a test plan.")
existing_user = Membership(first_name=self._TEST_PARAMS["first_name"],
last_name=self._TEST_PARAMS["last_name"],
email=self._TEST_PARAMS["email"],
spreedly_token=None,
username="******",
password="******",
plan=plan.name)
existing_user.put()
response = self.test_app.post("/", self._TEST_PARAMS)
self.assertEqual(302, response.status_int)
self.assertIn("subs.pinpayments.com", response.location)
self.assertIn(plan.plan_id, response.location)
self.assertIn(existing_user.username, response.location)
self.assertNotIn(existing_user.password, response.location)
def setUp(self):
# Create and activate testbed instance.
self.testbed = testbed.Testbed()
self.testbed.activate()
self.api_simulation = PinPaymentsApiSimulator()
self.test_member = Membership(first_name="Test",
last_name="Tester",
email="*****@*****.**",
plan="normal")
# Make sure all the plans we're testing with get constructed correctly.
plans.Plan.all_plans = []
plans.Plan.legacy_pairs = set([])
self.normal = plans.Plan("normal", 1, 100, "A test plan.")
self.legacy = plans.Plan("legacy",
1,
100,
"A test plan.",
legacy=self.normal)
def setUp(self):
super(AccountHandlerBase, self).setUp()
# Start by putting a user in the datastore.
user = Membership(first_name="Testy",
last_name="Testerson",
email="*****@*****.**",
plan=None,
status=None,
hash="anunlikelyhash")
user.put()
self.user_hash = user.hash
# Add the plans we need.
Plan.all_plans = []
Plan.legacy_pairs = set()
self.test_plan = Plan("test", 0, 100, "A test plan.")
# Clear fake usernames between tests.
ProjectHandler.clear_usernames()
def fix_autojoin(self, commit=True):
from membership import Membership
config_autojoin = config.get('adhocracy.instances.autojoin')
if config_autojoin == 'ALL':
instances = Instance.all(include_hidden=True)
else:
instance_keys = [key.strip() for key in config_autojoin.split(",")]
instances = meta.Session.query(Instance)\
.filter(Instance.key.in_(instance_keys)).all()
to_join = set(instances)
added = 0
for m in self.memberships:
to_join.discard(m.instance)
for instance in to_join:
autojoin_membership = Membership(self, instance,
instance.default_group)
meta.Session.add(autojoin_membership)
added += 1
if commit:
meta.Session.commit()
return added
def setUp(self):
# Set up testing for application.
self.test_app = webtest.TestApp(tasks.app)
# Set up datastore for testing.
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub()
self.testbed.init_taskqueue_stub()
self.testbed.init_mail_stub()
self.testbed.init_memcache_stub()
# Add a user to the datastore.
self.user = Membership(first_name="Testy",
last_name="Testerson",
email="*****@*****.**",
hash="notahash",
spreedly_token="notatoken",
username="******",
password="******")
self.user.put()
self.mail_stub = self.testbed.get_stub(testbed.MAIL_SERVICE_NAME)
def test_ignore_long_suspensions(self):
# Ensure that we have a known value for when we start ignoring plans.
conf = Config()
conf.PLAN_USER_IGNORE_THRESHOLD = 30
self.plan1.member_limit = 1
user = Membership(first_name="Testy",
last_name="Testerson",
email="*****@*****.**",
plan="plan1",
status="active")
user.put()
# Initially, the plan should be full, for every status.
self.assertTrue(self.plan1.is_full())
user.status = "suspended"
user.put()
self.assertTrue(self.plan1.is_full())
user.status = None
user.put()
self.assertTrue(self.plan1.is_full())
# If we mess with the updated time, it should be ignored when the plan is
# not active.
user.updated = datetime.datetime.now() - datetime.timedelta(days=31)
user.status = "active"
user.put(skip_time_update=True)
self.assertTrue(self.plan1.is_full())
user.status = "suspended"
user.put(skip_time_update=True)
self.assertFalse(self.plan1.is_full())
user.status = None
user.put(skip_time_update=True)
self.assertFalse(self.plan1.is_full())
def setUp(self):
self.membership = Membership()
def main(argv):
target_url = ''
COMMAND = ''
ALL = False
AUTH = False
DATASOURCE = False
TERM = False
COURSE = False
USER = False
MEMBERSHIP = False
CLEANUP = False
datasource_PK1 = None
datasource_session = None
usageStr = "\nrestdemo.py -t|--target <target root URL> -c|--command <command>\n"
usageStr += "e.g restdemo.py -t www.myschool.edu -c create_course\n"
usageStr += "command: <command>_<object> where <command> is one of the following:\n"
usageStr += "\tcreate, read, read_all_, read_all_course_memberships, read_all_user_memberships, update, delete\n"
usageStr += "and <object> is one of the following:\n"
usageStr += "\tdatasource, term, course, user\n"
usageStr += "-t is required; No -c args will run demo in predetermined order.\n"
usageStr += "'-c authorize' demomonstrates the authorization process and does not create objects."
usageStr += "-c commands require a valid datasource PK1 - \n"
usageStr += "\ta datasource get will be run in these cases, defaulting to create\n"
usageStr += "\tif the demo datasource does not exist."
if len(sys.argv) > 1: #there are command line arguments
try:
opts, args = getopt.getopt(argv, "ht:c:", ["target=", "command="])
except getopt.GetoptError:
print(usageStr)
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
print(usageStr)
sys.exit()
elif opt == '-d':
print("Deleting at end of run.")
CLEANUP = True
elif opt in ("-t", "--target"):
target_url = arg.lstrip()
elif opt in ("-c", "--command"):
COMMAND = arg
else:
COMMAND = "Run All"
print('[main] Target is:', target_url)
print('[main] Command is:', COMMAND)
else:
print(usageStr)
sys.exit(2)
#Set up some booleans for processing flags and order of processing
if "course" in COMMAND:
print("[main] Run course command")
COURSE = True
elif "membership" in COMMAND:
print("[main] Run membership command")
MEMBERSHIP = True
elif "user" in COMMAND:
print("[main] Run user command")
USER = True
elif "term" in COMMAND:
print("[main] Run term command")
TERM = True
elif "datasource" in COMMAND:
print("[main] Run datasource command")
DATASOURCE = True
elif "authorize" in COMMAND:
print("[main] Run authorization command")
AUTH = True
else:
print("[main] Empty Command: Run All\n")
ALL = True
print('\n[main] Acquiring auth token...\n')
authorized_session = AuthToken(target_url)
authorized_session.setToken()
print('\n[main] Returned token: ' + authorized_session.getToken() + '\n')
if not AUTH:
#run commands in required order if running ALL
if DATASOURCE or ALL:
#process Datasource command
print("\n[main] Run datasource command: " +
('ALL' if ALL else COMMAND) + '...')
datasource_session = DataSource(target_url,
authorized_session.getToken())
if 'datasource' in COMMAND:
datasource_session.execute(COMMAND,
authorized_session.getToken())
else:
if not datasource_PK1 or datasource_PK1 is None:
datasource_session.createDataSource(
authorized_session.getToken())
datasource_session.getDataSource(
authorized_session.getToken())
datasource_session.getDataSources(
authorized_session.getToken())
datasource_session.updateDataSource(
authorized_session.getToken())
if TERM or ALL:
term_session = Term(target_url, authorized_session.getToken())
#process term command
print("\n[main] Run term command: " + ('ALL' if ALL else COMMAND) +
'...')
if 'term' in COMMAND:
if (('delete' in COMMAND) or ('read' in COMMAND)):
print(
"[main] Deleting or getting does not require a datasource."
)
else:
if not datasource_PK1:
print("[main] confirm datasource.")
datasource_session = DataSource(
target_url, authorized_session.getToken())
datasource_session.checkDataSource(
authorized_session.getToken())
term_session.execute(COMMAND, "externalId:" + TERMEXTERNALID,
authorized_session.getToken())
else:
term_session.getTerms(authorized_session.getToken())
term_session.createTerm("externalId:" + DSKEXTERNALID,
authorized_session.getToken())
term_session.getTerm(authorized_session.getToken())
term_session.updateTerm("externalId:" + DSKEXTERNALID,
authorized_session.getToken())
if COURSE or ALL:
course_session = Course(target_url, authorized_session.getToken())
#process course command
print("\n[main] Run course command: " +
('ALL' if ALL else COMMAND) + '...')
if 'course' in COMMAND:
if (('delete' in COMMAND) or ('read' in COMMAND)):
print(
"[main] Deleting or getting does not require a datasource."
)
else:
if not datasource_PK1:
print("[main] confirm datasource.")
datasource_session = DataSource(
target_url, authorized_session.getToken())
datasource_session.checkDataSource(
authorized_session.getToken())
course_session.execute(COMMAND, "externalId:" + DSKEXTERNALID,
authorized_session.getToken())
else:
course_session.getCourses(authorized_session.getToken())
course_session.createCourse("externalId:" + DSKEXTERNALID,
authorized_session.getToken())
course_session.getCourse(authorized_session.getToken())
course_session.updateCourse("externalId:" + DSKEXTERNALID,
authorized_session.getToken())
if USER or ALL:
user_session = User(target_url, authorized_session.getToken())
#process user command
print("\n[main] Run user command: " + ('ALL' if ALL else COMMAND) +
'...')
if 'user' in COMMAND:
if (('delete' in COMMAND) or ('read' in COMMAND)):
print(
"[main] Deleting or getting does not require a datasource."
)
else:
if not datasource_PK1:
print("[main] confirm datasource.")
datasource_session = DataSource(
target_url, authorized_session.getToken())
datasource_session.checkDataSource(
authorized_session.getToken())
user_session.execute(COMMAND, "externalId:" + DSKEXTERNALID,
authorized_session.getToken())
else:
user_session.getUsers(authorized_session.getToken())
user_session.createUser("externalId:" + DSKEXTERNALID,
authorized_session.getToken())
user_session.getUser(authorized_session.getToken())
user_session.updateUser("externalId:" + DSKEXTERNALID,
authorized_session.getToken())
if MEMBERSHIP or ALL:
membership_session = Membership(target_url,
authorized_session.getToken())
#process membership command
print("\n[main] Run membership command: " +
('ALL' if ALL else COMMAND) + '...')
if 'membership' in COMMAND:
if (('delete' in COMMAND) or ('read' in COMMAND)):
print(
"[main] Deleting or getting does not require a datasource."
)
else:
if not datasource_PK1:
print("[main] confirm datasource.")
datasource_session = DataSource(
target_url, authorized_session.getToken())
datasource_session.checkDataSource(
authorized_session.getToken())
membership_session.execute(COMMAND,
"externalId:" + DSKEXTERNALID,
authorized_session.getToken())
else:
membership_session.getCourseMemberships(
authorized_session.getToken())
membership_session.createMembership(
"externalId:" + DSKEXTERNALID,
authorized_session.getToken())
membership_session.getUserMemberships(
authorized_session.getToken())
membership_session.updateMembership(
"externalId:" + DSKEXTERNALID,
authorized_session.getToken())
membership_session.readUserMemberships(
authorized_session.getToken())
#clean up if not using individual commands
if ALL:
print('\n[main] Completing Demo and deleting created objects...')
print("[main] Deleting membership")
membership_session.deleteMembership(authorized_session.getToken())
print("[main] Deleting Course")
user_session.deleteUser(authorized_session.getToken())
print("[main] Deleting Course")
course_session.deleteCourse(authorized_session.getToken())
print("[main] Deleting Term")
term_session.deleteTerm(authorized_session.getToken())
print("[main] Deleting DataSource")
datasource_session.deleteDataSource(authorized_session.getToken())
else:
print("\nRemember to delete created demo objects!")
print("[main] Processing Complete")
def __init__(self, name, id, timestamp, age):
super().__init__(timestamp, age)
self.name = name
self.membershipID = Membership(id, 1)
def setUp(self):
self.membership = Membership('10', '03012020', 'silver')
def post(self):
first_name = self.request.get("first_name")
last_name = self.request.get("last_name")
twitter = self.request.get("twitter").lower().strip().strip("@")
email = self.request.get("email").lower().strip()
plan = self.request.get("plan")
if not first_name or not last_name or not email:
self.response.out.write(
self.render("templates/main.html",
message="Sorry, we need name and email address.",
plan=plan))
self.response.set_status(400)
return
membership = db.GqlQuery(
"SELECT * FROM Membership WHERE email = :email",
email=email).get()
if membership:
# A membership object already exists in the datastore.
if membership.extra_dnd == True:
self.response.out.write(
"Error #237. Please contact [email protected]")
self.response.set_status(422)
return
if membership.status == "suspended":
self.response.out.write(self.render("templates/main.html",
message="Your account has been suspended." \
" <a href=\"/reactivate\">Click here</a> to reactivate.",
plan=plan))
self.response.set_status(422)
return
elif membership.status in ("active", "no_visits"):
self.response.out.write(
self.render("templates/main.html",
message="Account already exists.",
plan=plan))
self.response.set_status(422)
return
elif ((membership.username and membership.password and \
membership.plan) and not membership.spreedly_token):
# They've already filled out everything, but they haven't started a
# subscription. Take them to the PinPayments page.
logging.info("Taking user %s directly to PinPayments page." %
(membership.username))
self.redirect(membership.new_subscribe_url(self.request.host))
return
else:
# Existing membership never got activated. Overwrite it.
logging.info("Overwriting existing membership for %s." %
(email))
membership.first_name = first_name
membership.last_name = last_name
membership.email = email
membership.twitter = twitter
else:
# Make a new membership object.
membership = Membership(first_name=first_name,
last_name=last_name,
email=email,
twitter=twitter)
if self.request.get("paypal") == "1":
membership.status = "paypal"
membership.hash = hashlib.md5(membership.email).hexdigest()
if "1337" in self.request.get("referrer").upper():
membership.referrer = re.sub("[^0-9]", "",
self.request.get("referrer").upper())
else:
membership.referrer = self.request.get("referrer").replace(
"\n", " ")
membership.put()
logging.debug("Using plan: %s" % (plan))
if plan == "choose":
# Have the user select a plan.
self.redirect("/plan/%s" % (membership.hash))
else:
# A plan was specified for us, so go on to creating the account.
logging.info("Got plan '%s', skipping plan selection step." %
(plan))
query = urllib.urlencode({"plan": plan})
self.redirect("/account/%s?%s" % (membership.hash, query))
def process_memberships(req_number_memberships, index, output_file, rest):
# randomizing n memberships for n users into n courses can be tricky -
# if you have a better way of doing this let me know - [email protected]
print("PROCESSING MEMBERSHIPS...")
indx = int(index) #starting index for courses and users
memberships_count = 0
full = set()
course_memberships = {}
courses = set()
users = set()
courses_with_members = set()
users_in_courses = set()
#req_number is the required number of memberships - user entered or constant max of 1000
if int(req_number_memberships) == 1000:
req_number_users = 150
req_number_courses = 100
else:
req_number_users = req_number_memberships
req_number_courses = req_number_memberships
print("number memberships in: %d" % req_number_memberships)
print("number users in: %d" % req_number_users)
print("number courses in: %d" % req_number_courses)
#build membership lists for courses
#create arrays containing memberships randomly associated with courses until
#req_number_memberships is met.
#Since membership count is the control:
# all courses may not have memberships
# all users may not have memberships
while memberships_count < req_number_memberships:
user_set = set()
userID = USEREXTERNALIDSTEM + "_" + str(
random.randint(int(index),
int(index) + int(req_number_users) - 1))
#print ("userID %d" % userID)
courseID = COURSEEXTERNALIDSTEM + "_" + str(
random.randint(int(index),
int(index) + int(req_number_courses) - 1))
#print ("courseID %d" % courseID)
if courseID in course_memberships and courseID not in full:
user_set = set(course_memberships[courseID])
#print ("%s is not full - adding membership" % courseID)
user_set.add(userID)
course_memberships[courseID] = list(user_set)
courses_with_members.add("%s_%s" % (COURSEEXTERNALIDSTEM, courseID))
users_in_courses.add("%s_%s" % (USEREXTERNALIDSTEM, userID))
memberships_count += 1
#check if full add to full set.
if len(user_set) >= MAX_PER_COURSE_MEMBERSHIPS:
#print ("%s is full." % courseID)
full.add(courseID)
#what courses did not get members?
all_courses = []
for num in range(indx, indx + int(req_number_courses) - 1):
all_courses.append("%s_%d" % (COURSEEXTERNALIDSTEM, num))
with open(
output_file + "Courses_with_no_enrollments-" +
datetime.datetime.now().strftime("%Y%m%d-%H%M%S") + ".txt",
"w") as text_file:
text_file.write(
"\n##### This file contains the list of courses not given enrollments #####\n"
)
text_file.write(str(set(all_courses) - courses_with_members))
print("COURSES WITH NO ENROLLMENTS FILE WRITTEN")
#what users did not get into courses?
all_users = []
for num in range(indx, indx + int(req_number_users) - 1):
all_users.append("%s_%d" % (USEREXTERNALIDSTEM, num))
#print (all_courses)
with open(
output_file + "Users_with_no_enrollments-" +
datetime.datetime.now().strftime("%Y%m%d-%H%M%S") + ".txt",
"w") as text_file:
text_file.write(
"\n##### This file contains the list of users not enrolled in a course #####\n"
)
text_file.write(str(set(all_users) - users_in_courses))
print("USERS WITH NO ENROLLMENTS FILE WRITTEN")
#print (set(all_users) - users_in_courses)
if rest:
print(
"WRITING DATA FILE and PROCESSING via REST, this will take a minute or so..."
)
else:
print("WRITING DATA FILE ONLY - you must process via SIS Framework...")
with open(
output_file + "_MEMBERSHIPS-" +
datetime.datetime.now().strftime("%Y%m%d-%H%M%S") + ".txt",
"w") as text_file:
text_file.write(
"\n##### DELETE THIS LINE....THE FOLLOWING IS A MEMBERSHIP SNAPSHOT FLAT FILE FOR STORE OR DELETE #####\n"
)
text_file.write("##### DELETE THIS LINE.... DATASOURCEKEY %s #####\n" %
DSKEXTERNALID)
text_file.write("EXTERNAL_COURSE_KEY|EXTERNAL_PERSON_KEY|ROLE\n")
if rest:
print(
"WRITING DATA FILE and PROCESSING via REST, this will take a minute or so..."
)
extId = "externalId:%s" % DSKEXTERNALID
#same payload used for all membership requests
json_payload = {
"dataSourceId": extId,
"availability": {
"available": "Yes"
},
"courseRoleId": "Student"
}
else:
print(
"WRITING DATA FILE ONLY - you must process via SIS Framework..."
)
counter = 0
# take the above course_memberships dictionary,
# iterate through the keys,
# the values are the list of userIDs by index
# write the snapshot file and
# if REST send the request payload
for key in course_memberships:
courseID = key
userID_list = course_memberships[key]
for user in userID_list:
text_file.write("%s|%s|Student\n" % (key, user))
if rest:
global authorized_session
membership_session = Membership(
rest, authorized_session.getToken())
membership_session.createMembership(
courseID, user, json.dumps(json_payload),
authorized_session.getToken())
