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())