Exemple #1
0
    def _processEntity(self, entity):
        key_name = entity.key().name()
        parent = entity.scope
        properties = {
            'abstract': entity.abstract,
            'additional_info': entity.additional_info,
            'content': entity.content,
            'created_on': entity.created_on,
            'is_publicly_visible': entity.is_publicly_visible,
            'last_modified_on': entity.last_modified_on,
            'mentor': entity.mentor,
            'org': entity.org,
            'possible_mentors': entity.possible_mentors,
            'program': entity.program,
            'status': entity.status,
            'title': entity.title,
        }

        # check if the proposal has already been processed
        # this is a heristic, but we can assume that one student can't submit two
        # proposals at the very same time
        query = db.Query(GSoCProposal)
        query.ancestor(entity.scope)
        query.filter('created_on = ', entity.created_on)
        if query.get():
            return

        # create a new GSoCProposal entity
        proposal = GSoCProposal(parent=parent, **properties)
        proposal.put()

        to_put = []
        # convert all the comments for the old proposal
        query = db.Query(Review)
        query.filter('scope = ', entity)
        for comment in query:
            # get profile instance
            q = db.Query(GSoCProfile)
            q.ancestor(comment.author)
            q.filter('scope =', entity.program)
            author = q.get()

            if not author:
                # if, for some reason, there is no profile, we skip this comment
                import logging
                logging.warning('No profile for user %s.' %
                                (comment.author.link_id))
                continue

            properties = {
                'author': author,
                'content': comment.content,
                'is_private': not comment.is_public,
                'created': comment.created
            }
            new_comment = GSoCComment(parent=proposal, **properties)
            to_put.append(new_comment)

        db.run_in_transaction(db.put, to_put)
  def _processEntity(self, entity):
    key_name = entity.key().name()
    parent = entity.scope
    properties = {
        'abstract': entity.abstract,
        'additional_info': entity.additional_info,
        'content': entity.content,
        'created_on': entity.created_on,
        'is_publicly_visible': entity.is_publicly_visible,
        'last_modified_on': entity.last_modified_on,
        'mentor': entity.mentor,
        'org': entity.org,
        'possible_mentors': entity.possible_mentors,
        'program': entity.program,
        'status': entity.status,
        'title': entity.title,
        }

    # check if the proposal has already been processed
    # this is a heristic, but we can assume that one student can't submit two
    # proposals at the very same time
    query = db.Query(GSoCProposal)
    query.ancestor(entity.scope)
    query.filter('created_on = ', entity.created_on)
    if query.get():
      return

    # create a new GSoCProposal entity
    proposal = GSoCProposal(parent=parent, **properties)
    proposal.put()
    
    to_put = []
    # convert all the comments for the old proposal
    query = db.Query(Review)
    query.filter('scope = ', entity)
    for comment in query:
      # get profile instance
      q = db.Query(GSoCProfile)
      q.ancestor(comment.author)
      q.filter('scope =', entity.program)
      author = q.get()

      if not author:
        # if, for some reason, there is no profile, we skip this comment
        import logging
        logging.warning('No profile for user %s.' % (comment.author.link_id))
        continue

      properties = {
          'author': author,
          'content': comment.content,
          'is_private': not comment.is_public,
          'created': comment.created
          }
      new_comment = GSoCComment(parent=proposal, **properties)
      to_put.append(new_comment)

    db.run_in_transaction(db.put, to_put)
Exemple #3
0
        def create_proposal_trx():
            profile = data.ndb_profile.key.get()
            profile.student_data.number_of_proposals += 1
            profile.put()

            proposal = GSoCProposal(parent=data.ndb_profile.key.to_old_key(),
                                    **proposal_properties)
            proposal.put()

            context = notifications.newProposalContext(data, proposal,
                                                       to_emails)
            sub_txn = mailer.getSpawnMailTaskTxn(context, parent=proposal)
            sub_txn()

            return proposal
Exemple #4
0
    def create_proposal_trx():
      profile = data.ndb_profile.key.get()
      profile.student_data.number_of_proposals += 1
      profile.put()

      proposal = GSoCProposal(
          parent=data.ndb_profile.key.to_old_key(),
          **proposal_properties)
      proposal.put()

      context = notifications.newProposalContext(data, proposal, to_emails)
      sub_txn = mailer.getSpawnMailTaskTxn(context, parent=proposal)
      sub_txn()

      return proposal
Exemple #5
0
def seed(request, *args, **kwargs):
  """Seeds the datastore with some default values.
  """

  site_properties = {
      'key_name': 'site',
      'latest_gsoc': 'google/gsoc2014',
      'latest_gci': 'google/gci2013',
      }
  site = Site(**site_properties)
  site.put()

  account = accounts.getCurrentAccount()

  if not account:
    account = users.User(email='*****@*****.**')

  user_properties = {
      'id': 'test',
      'account_id': account.user_id(),
      'account': account,
      }
  current_user = user.User(**user_properties)
  current_user.put()

  group_properties = {
       'key_name': 'google',
       'link_id': 'google',
       'name': 'Google Inc.',
       'short_name': 'Google',
       'home_page': 'http://www.google.com',
       'email': '*****@*****.**',
       'description': 'This is the profile for Google.',
       'contact_street': 'Some Street',
       'contact_city': 'Some City',
       'contact_country': 'United States',
       'contact_postalcode': '12345',
       'phone': '15551110000',
       'status': 'active',
       }
  google = Sponsor(**group_properties)
  google.put()

  now = datetime.datetime.now()
  before = now - datetime.timedelta(365)
  after = now + datetime.timedelta(365)
  past_before = before - datetime.timedelta(2 * 365)
  past_after = after - datetime.timedelta(2 * 365)

  timeline_properties = {
      'key_name': 'google/gsoc2014',
      'link_id': 'gsoc2014',
      'scope': google,
      'program_start': before,
      'program_end': after,
      'accepted_organization_announced_deadline': before,
      'accepted_students_announced_deadline' : after,
      'student_signup_start': before,
      'student_signup_end': after,
      'application_review_deadline': after,
      'student_application_matched_deadline': after,
      'accepted_students_announced_deadline': after,
      'form_submission_start': before,
  }
  gsoc2014_timeline = GSoCTimeline(**timeline_properties)
  gsoc2014_timeline.put()

  program_properties = {
      'key_name': 'google/gsoc2014',
      'link_id': 'gsoc2014',
      'program_id': 'gsoc2014',
      'sponsor': google,
      'scope': google,
      'name': 'Google Summer of Code 2014',
      'short_name': 'GSoC 2014',
      'description': 'This is the program for GSoC 2014.',
      'apps_tasks_limit': 42,
      'slots': 42,
      'timeline': gsoc2014_timeline,
      'status': program_model.STATUS_VISIBLE,
      }
  gsoc2014 = GSoCProgram(**program_properties)
  gsoc2014.put()

  timeline_properties.update({
      'key_name': 'google/gsoc2010',
      'link_id': 'gsoc2010',
      'program_start': past_before,
      'program_end': past_after,
      'accepted_organization_announced_deadline': past_before,
      'accepted_students_announced_deadline' : past_after,
      'student_signup_start': past_before,
      'student_signup_end': past_after,
      'application_review_deadline': past_after,
      'student_application_matched_deadline': past_after,
      'accepted_students_announced_deadline': past_after,
      'form_submission_start': past_before,
  })
  gsoc2010_timeline = GSoCTimeline(**timeline_properties)
  gsoc2010_timeline.put()

  program_properties.update({
      'key_name': 'google/gsoc2010',
      'link_id': 'gsoc2010',
      'program_id': 'gsoc2010',
      'name': 'Google Summer of Code 2010',
      'description': 'This is the program for GSoC 2010.',
      'short_name': 'GSoC 2010',
      'timeline': gsoc2010_timeline,
  })
  gsoc2010 = GSoCProgram(**program_properties)
  gsoc2010.put()

  # TODO(drew): Replace gsoc2014.prefix with whatever its replacement becomes
  # once prefix is removed from program and no longer used in the query for
  # OrgAppSurvey in soc.views.helper.RequestData._getProgramWideFields().
  org_app_survey_properties = {
    'key_name' : '%s/%s/orgapp' % (gsoc2014.prefix, gsoc2014.key().name()),
    'program' : gsoc2014,
    'title' : 'Org App Survey',
    'content' : 'Here is some content.',
    'modified_by' : current_user.key.to_old_key(),
    'survey_start' : before,
    'survey_end' : after
  }
  org_app_survey_model.OrgAppSurvey(**org_app_survey_properties).put()

  org_app_survey_properties['key_name'] = ('%s/%s/orgapp' % (
      gsoc2010.prefix, gsoc2010.key().name()))
  org_app_survey_properties['program'] = gsoc2010
  org_app_survey_properties['survey_start'] = past_before
  org_app_survey_properties['survey_end'] = past_after
  org_app_survey_model.OrgAppSurvey(**org_app_survey_properties).put()

  timeline_properties = {
        'key_name': 'google/gci2013',
        'link_id': 'gci2013',
        'scope': google,
        'program_start': before,
        'program_end': after,
        'accepted_organization_announced_deadline': before,
        'student_signup_start': before,
        'student_signup_end': after,
        'tasks_publicly_visible': before,
        'task_claim_deadline': after,
        'stop_all_work_deadline': after,
  }
  gci2013_timeline = GCITimeline(**timeline_properties)
  gci2013_timeline.put()

  program_properties.update({
      'key_name': 'google/gci2013',
      'link_id': 'gci2013',
      'program_id': 'gci2013',
      'name': 'Google Code In Contest 2013',
      'short_name': 'GCI 2009',
      'description': 'This is the program for GCI 2013.',
      'timeline': gci2013_timeline,
      })
  gci2013 = GCIProgram(**program_properties)
  gci2013.put()

  site.active_program = gci2013
  site.put()

  current_user.host_for = [
      ndb.Key.from_old_key(gsoc2010.key()),
      ndb.Key.from_old_key(gsoc2014.key()),
      ndb.Key.from_old_key(gci2013.key())]
  current_user.put()

  group_properties.update({
    'key_name': 'google/gci2013/melange',
    'link_id': 'melange',
    'name': 'Melange Development Team',
    'short_name': 'Melange',
    'scope': gci2013,
    'program': gci2013,
    'sponsor': google,
    'home_page': 'http://code.google.com/p/soc',
    'description': 'Melange, share the love!',
    'license_name': 'Apache License',
    'ideas': 'http://code.google.com/p/soc/issues',
    })
  melange = GCIOrganization(**group_properties)
  melange.put()

  group_properties.update({
    'scope': gsoc2014,
    'program': gsoc2014,
    })

  address_properties = address.Address(
      street='1 Test St.',
      city='Some City',
      country='United States',
      postal_code='12345')
  address_properties.put()

  contact_info = contact.Contact(email='*****@*****.**')
  contact_info.put()

  gsoc_delta = datetime.timedelta(days=(365 * 18))

  profile_properties = {
      'id': gsoc2014.key().name() + '/' + current_user.key.id(),
      'parent': current_user.key,
      'public_name': 'test',
      'program': ndb.Key.from_old_key(gsoc2014.key()),
      'first_name': 'Test',
      'last_name': 'Example',
      'contact' : contact_info,
      'residential_address' : address_properties,
      'shipping_address' : address_properties,
      'birth_date' : datetime.date.today() - gsoc_delta,
      'program_knowledge' : 'Friend referral',
      }
  profile = profile_model.Profile(**profile_properties)

  ndb_orgs = []
  for i in range(15):
    group_properties.update({
        'key_name': 'google/gsoc2014/org_%d' % i,
        'link_id': 'org_%d' % i,
        'name': 'Organization %d' % i,
        'short_name': 'Org %d' % i,
        'description': 'Organization %d!' % i,
        })

    org_properties = {
        'name': 'Organization %d' % i,
        'org_id': 'org_%d' % i,
        'program': ndb.Key.from_old_key(gsoc2014.key()),
        'description': 'Organization %d!' % i,
        }
    org = soc_org_model.SOCOrganization(
        id='google/gsoc2014/org_%d' % i, **org_properties)
    org.put()
    ndb_orgs.append(org)

    # Admin (and thus mentor) for the first org
    if i == 0:
      profile.admin_for.append(org.key)
      profile.mentor_for.append(org.key)
      profile.put()

    # Mentor for the second org
    if i == 1:
      profile.mentor_for.append(org.key)
      profile.put()

  profile_properties.update({
      'id': gci2013.key().name() + '/' + current_user.key.id(),
      'parent': current_user.key,
      'program': ndb.Key.from_old_key(gci2013.key()),
      'admin_for': [ndb.Key.from_old_key(melange.key())],
      'mentor_for': [ndb.Key.from_old_key(melange.key())],
      })
  melange_admin = profile_model.Profile(**profile_properties)
  # TODO: add GCI orgs
  melange_admin.put()

  task_properties = {
      'status': 'Open',
      'modified_by': melange_admin.key.to_old_key(),
      'subscribers': [melange_admin.key.to_old_key()],
      'title': 'Awesomeness',
      'created_by': melange_admin.key.to_old_key(),
      'created_on': now,
      'program': gci2013,
      'time_to_complete': 1337,
      'modified_on': now,
      'org': melange.key(),
      'description': '<p>AWESOME</p>',
      'difficulty_level': DifficultyLevel.MEDIUM,
      'types': ['Code']
  }
  gci_task = GCITask(**task_properties)
  gci_task.put()

  user_properties = {
      'id': 'student',
      'account_id': '12345',
      'account': users.User(email='*****@*****.**'),
      }
  student_user = user.User(**user_properties)
  student_user.put()

  gci_delta = datetime.timedelta(days=(365 * 14))

  contact_properties = contact.Contact(
      email='*****@*****.**',
      web_page='http://www.homepage.com/',
      blog='http://www.blog.com/',
      phone='1650253000')
  contact_properties.put()

  graduation_year = datetime.date.today() + datetime.timedelta(days=365)

  student_data = soc_profile.SOCStudentData(
      education=education.Education(
          school_id="123",
          school_country="United States",
          expected_graduation=int(graduation_year.strftime('%Y')),
          major='Some Major',
          degree=education.Degree.UNDERGRADUATE)
      )
  student_data.put()

  student_id = 'student'
  student_properties = {
      'id': gsoc2014.key().name() + "/" + student_id,
      'parent': student_user.key,
      'program': ndb.Key.from_old_key(gsoc2014.key()),
      'public_name': 'Student',
      'first_name': 'Student',
      'last_name': 'Student',
      'contact' : contact_properties,
      'residential_address' : address_properties,
      'shipping_address' : address_properties,
      'birth_date': datetime.date.today() - gci_delta,
      'tee_size': profile_model.TeeSize.L,
      'tee_style': profile_model.TeeStyle.MALE,
      'gender' : profile_model.Gender.MALE,
      'program_knowledge': 'Friend referral.',
      'student_data' : student_data,
      }
  melange_student = profile_model.Profile(**student_properties)
  melange_student.put()

  student_id = 'student2'
  user_properties = {
      'id': student_id,
      'account_id': 'student2',
      'account': users.User(email='*****@*****.**'),
      }
  student_user2 = user.User(**user_properties)
  student_user2.put()

  student_properties.update({
      'id': gsoc2014.key().name() + "/" + student_id,
      'parent': student_user2.key,
      'first_name' : 'Student 2',
      'last_name' : 'Example'
  })
  melange_student2 = profile_model.Profile(**student_properties)
  melange_student2.put()

  proposal_properties = {
      'parent': melange_student.key.to_old_key(),
      'program': gsoc2014,
      'title': 'test proposal',
      'abstract': 'test abstract',
      'content': 'test content',
      'mentor': profile.key.to_old_key(),
      'status': 'accepted',
      'has_mentor': True,
      'org': ndb_orgs[0].key.to_old_key(),
      'possible_mentors': [profile.key.to_old_key()]
      }
  melange_proposal = GSoCProposal(**proposal_properties)
  melange_proposal.put()

  project_properties = {
      'title': 'test project',
      'abstract': 'test abstract',
      'status': 'accepted',
      'parent': melange_student.key.to_old_key(),
      'mentors': [profile.key.to_old_key()],
      'program':  gsoc2014,
      'org': ndb_orgs[0].key.to_old_key(),
      'proposal' : melange_proposal.key(),
       }
  melange_project = GSoCProject(**project_properties)
  melange_project.put()
  ndb_orgs[1].slot_allocation = 1
  ndb_orgs[1].put()

  student_data.number_of_projects = 1
  student_data.number_of_proposals = 1
  student_data.project_for_orgs = [ndb_orgs[1].key]

  melange_student.put()
  melange_student2.put()

  project_properties.update({
      'student': melange_student2,
      'title': 'test project2'
      })
  melange_project2 = GSoCProject(**project_properties)
  melange_project2.put()
  ndb_orgs[1].slot_allocation += 1
  ndb_orgs[1].put()

  student_id = 'student'
  student_properties.update({
      'id': gci2013.key().name() + '/' + student_id,
      'parent': student_user.key,
      'program': ndb.Key.from_old_key(gci2013.key()),
  })
  gci_student = profile_model.Profile(**student_properties)
  gci_student.put()

  score_properties = {
      'parent': gci_student.key.to_old_key(),
      'program': gci2013,
      'points': 5,
      'tasks': [gci_task.key()]
      }
  score = GCIScore(**score_properties)
  score.put()

  document_properties = {
      'key_name': 'site/site/home',
      'link_id': 'home',
      'scope': site,
      'prefix': 'site',
      'author': current_user.key.to_old_key(),
      'title': 'Home Page',
      'content': 'This is the Home Page',
      'modified_by': current_user.key.to_old_key(),
      }
  home_document = Document(**document_properties)
  home_document.put()

  document_properties = {
      'key_name': 'user/test/notes',
      'link_id': 'notes',
      'scope': current_user.key.to_old_key(),
      'prefix': 'user',
      'author': current_user.key.to_old_key(),
      'title': 'My Notes',
      'content': 'These are my notes',
      'modified_by': current_user.key.to_old_key(),
      }
  notes_document = Document(**document_properties)
  notes_document.put()

  site.home = home_document
  site.put()

  memcache.flush_all()

  return http.HttpResponse('Done')
Exemple #6
0
def seed(request, *args, **kwargs):
    """Seeds the datastore with some default values.
  """

    site_properties = {
        'key_name': 'site',
        'latest_gsoc': 'google/gsoc2014',
        'latest_gci': 'google/gci2013',
    }
    site = Site(**site_properties)
    site.put()

    account = accounts.getCurrentAccount()

    if not account:
        account = users.User(email='*****@*****.**')

    user_properties = {
        'id': 'test',
        'account_id': account.user_id(),
        'account': account,
    }
    current_user = user.User(**user_properties)
    current_user.put()

    group_properties = {
        'key_name': 'google',
        'link_id': 'google',
        'name': 'Google Inc.',
        'short_name': 'Google',
        'home_page': 'http://www.google.com',
        'email': '*****@*****.**',
        'description': 'This is the profile for Google.',
        'contact_street': 'Some Street',
        'contact_city': 'Some City',
        'contact_country': 'United States',
        'contact_postalcode': '12345',
        'phone': '15551110000',
        'status': 'active',
    }
    google = Sponsor(**group_properties)
    google.put()

    now = datetime.datetime.now()
    before = now - datetime.timedelta(365)
    after = now + datetime.timedelta(365)
    past_before = before - datetime.timedelta(2 * 365)
    past_after = after - datetime.timedelta(2 * 365)

    timeline_properties = {
        'key_name': 'google/gsoc2014',
        'link_id': 'gsoc2014',
        'scope': google,
        'program_start': before,
        'program_end': after,
        'accepted_organization_announced_deadline': before,
        'accepted_students_announced_deadline': after,
        'student_signup_start': before,
        'student_signup_end': after,
        'application_review_deadline': after,
        'student_application_matched_deadline': after,
        'accepted_students_announced_deadline': after,
        'form_submission_start': before,
    }
    gsoc2014_timeline = GSoCTimeline(**timeline_properties)
    gsoc2014_timeline.put()

    program_properties = {
        'key_name': 'google/gsoc2014',
        'link_id': 'gsoc2014',
        'program_id': 'gsoc2014',
        'sponsor': google,
        'scope': google,
        'name': 'Google Summer of Code 2014',
        'short_name': 'GSoC 2014',
        'description': 'This is the program for GSoC 2014.',
        'apps_tasks_limit': 42,
        'slots': 42,
        'timeline': gsoc2014_timeline,
        'status': program_model.STATUS_VISIBLE,
    }
    gsoc2014 = GSoCProgram(**program_properties)
    gsoc2014.put()

    timeline_properties.update({
        'key_name': 'google/gsoc2010',
        'link_id': 'gsoc2010',
        'program_start': past_before,
        'program_end': past_after,
        'accepted_organization_announced_deadline': past_before,
        'accepted_students_announced_deadline': past_after,
        'student_signup_start': past_before,
        'student_signup_end': past_after,
        'application_review_deadline': past_after,
        'student_application_matched_deadline': past_after,
        'accepted_students_announced_deadline': past_after,
        'form_submission_start': past_before,
    })
    gsoc2010_timeline = GSoCTimeline(**timeline_properties)
    gsoc2010_timeline.put()

    program_properties.update({
        'key_name': 'google/gsoc2010',
        'link_id': 'gsoc2010',
        'program_id': 'gsoc2010',
        'name': 'Google Summer of Code 2010',
        'description': 'This is the program for GSoC 2010.',
        'short_name': 'GSoC 2010',
        'timeline': gsoc2010_timeline,
    })
    gsoc2010 = GSoCProgram(**program_properties)
    gsoc2010.put()

    # TODO(drew): Replace gsoc2014.prefix with whatever its replacement becomes
    # once prefix is removed from program and no longer used in the query for
    # OrgAppSurvey in soc.views.helper.RequestData._getProgramWideFields().
    org_app_survey_properties = {
        'key_name': '%s/%s/orgapp' % (gsoc2014.prefix, gsoc2014.key().name()),
        'program': gsoc2014,
        'title': 'Org App Survey',
        'content': 'Here is some content.',
        'modified_by': current_user.key.to_old_key(),
        'survey_start': before,
        'survey_end': after
    }
    org_app_survey_model.OrgAppSurvey(**org_app_survey_properties).put()

    org_app_survey_properties['key_name'] = (
        '%s/%s/orgapp' % (gsoc2010.prefix, gsoc2010.key().name()))
    org_app_survey_properties['program'] = gsoc2010
    org_app_survey_properties['survey_start'] = past_before
    org_app_survey_properties['survey_end'] = past_after
    org_app_survey_model.OrgAppSurvey(**org_app_survey_properties).put()

    timeline_properties = {
        'key_name': 'google/gci2013',
        'link_id': 'gci2013',
        'scope': google,
        'program_start': before,
        'program_end': after,
        'accepted_organization_announced_deadline': before,
        'student_signup_start': before,
        'student_signup_end': after,
        'tasks_publicly_visible': before,
        'task_claim_deadline': after,
        'stop_all_work_deadline': after,
    }
    gci2013_timeline = GCITimeline(**timeline_properties)
    gci2013_timeline.put()

    program_properties.update({
        'key_name': 'google/gci2013',
        'link_id': 'gci2013',
        'program_id': 'gci2013',
        'name': 'Google Code In Contest 2013',
        'short_name': 'GCI 2009',
        'description': 'This is the program for GCI 2013.',
        'timeline': gci2013_timeline,
    })
    gci2013 = GCIProgram(**program_properties)
    gci2013.put()

    site.active_program = gci2013
    site.put()

    current_user.host_for = [
        ndb.Key.from_old_key(gsoc2010.key()),
        ndb.Key.from_old_key(gsoc2014.key()),
        ndb.Key.from_old_key(gci2013.key())
    ]
    current_user.put()

    group_properties.update({
        'key_name': 'google/gci2013/melange',
        'link_id': 'melange',
        'name': 'Melange Development Team',
        'short_name': 'Melange',
        'scope': gci2013,
        'program': gci2013,
        'sponsor': google,
        'home_page': 'http://code.google.com/p/soc',
        'description': 'Melange, share the love!',
        'license_name': 'Apache License',
        'ideas': 'http://code.google.com/p/soc/issues',
    })
    melange = GCIOrganization(**group_properties)
    melange.put()

    group_properties.update({
        'scope': gsoc2014,
        'program': gsoc2014,
    })

    address_properties = address.Address(street='1 Test St.',
                                         city='Some City',
                                         country='United States',
                                         postal_code='12345')
    address_properties.put()

    contact_info = contact.Contact(email='*****@*****.**')
    contact_info.put()

    gsoc_delta = datetime.timedelta(days=(365 * 18))

    profile_properties = {
        'id': gsoc2014.key().name() + '/' + current_user.key.id(),
        'parent': current_user.key,
        'public_name': 'test',
        'program': ndb.Key.from_old_key(gsoc2014.key()),
        'first_name': 'Test',
        'last_name': 'Example',
        'contact': contact_info,
        'residential_address': address_properties,
        'shipping_address': address_properties,
        'birth_date': datetime.date.today() - gsoc_delta,
        'program_knowledge': 'Friend referral',
    }
    profile = profile_model.Profile(**profile_properties)

    ndb_orgs = []
    for i in range(15):
        group_properties.update({
            'key_name': 'google/gsoc2014/org_%d' % i,
            'link_id': 'org_%d' % i,
            'name': 'Organization %d' % i,
            'short_name': 'Org %d' % i,
            'description': 'Organization %d!' % i,
        })

        org_properties = {
            'name': 'Organization %d' % i,
            'org_id': 'org_%d' % i,
            'program': ndb.Key.from_old_key(gsoc2014.key()),
            'description': 'Organization %d!' % i,
        }
        org = soc_org_model.SOCOrganization(id='google/gsoc2014/org_%d' % i,
                                            **org_properties)
        org.put()
        ndb_orgs.append(org)

        # Admin (and thus mentor) for the first org
        if i == 0:
            profile.admin_for.append(org.key)
            profile.mentor_for.append(org.key)
            profile.put()

        # Mentor for the second org
        if i == 1:
            profile.mentor_for.append(org.key)
            profile.put()

    profile_properties.update({
        'id':
        gci2013.key().name() + '/' + current_user.key.id(),
        'parent':
        current_user.key,
        'program':
        ndb.Key.from_old_key(gci2013.key()),
        'admin_for': [ndb.Key.from_old_key(melange.key())],
        'mentor_for': [ndb.Key.from_old_key(melange.key())],
    })
    melange_admin = profile_model.Profile(**profile_properties)
    # TODO: add GCI orgs
    melange_admin.put()

    task_properties = {
        'status': 'Open',
        'modified_by': melange_admin.key.to_old_key(),
        'subscribers': [melange_admin.key.to_old_key()],
        'title': 'Awesomeness',
        'created_by': melange_admin.key.to_old_key(),
        'created_on': now,
        'program': gci2013,
        'time_to_complete': 1337,
        'modified_on': now,
        'org': melange.key(),
        'description': '<p>AWESOME</p>',
        'difficulty_level': DifficultyLevel.MEDIUM,
        'types': ['Code']
    }
    gci_task = GCITask(**task_properties)
    gci_task.put()

    user_properties = {
        'id': 'student',
        'account_id': '12345',
        'account': users.User(email='*****@*****.**'),
    }
    student_user = user.User(**user_properties)
    student_user.put()

    gci_delta = datetime.timedelta(days=(365 * 14))

    contact_properties = contact.Contact(email='*****@*****.**',
                                         web_page='http://www.homepage.com/',
                                         blog='http://www.blog.com/',
                                         phone='1650253000')
    contact_properties.put()

    graduation_year = datetime.date.today() + datetime.timedelta(days=365)

    student_data = soc_profile.SOCStudentData(education=education.Education(
        school_id="123",
        school_country="United States",
        expected_graduation=int(graduation_year.strftime('%Y')),
        major='Some Major',
        degree=education.Degree.UNDERGRADUATE))
    student_data.put()

    student_id = 'student'
    student_properties = {
        'id': gsoc2014.key().name() + "/" + student_id,
        'parent': student_user.key,
        'program': ndb.Key.from_old_key(gsoc2014.key()),
        'public_name': 'Student',
        'first_name': 'Student',
        'last_name': 'Student',
        'contact': contact_properties,
        'residential_address': address_properties,
        'shipping_address': address_properties,
        'birth_date': datetime.date.today() - gci_delta,
        'tee_size': profile_model.TeeSize.L,
        'tee_style': profile_model.TeeStyle.MALE,
        'gender': profile_model.Gender.MALE,
        'program_knowledge': 'Friend referral.',
        'student_data': student_data,
    }
    melange_student = profile_model.Profile(**student_properties)
    melange_student.put()

    student_id = 'student2'
    user_properties = {
        'id': student_id,
        'account_id': 'student2',
        'account': users.User(email='*****@*****.**'),
    }
    student_user2 = user.User(**user_properties)
    student_user2.put()

    student_properties.update({
        'id': gsoc2014.key().name() + "/" + student_id,
        'parent': student_user2.key,
        'first_name': 'Student 2',
        'last_name': 'Example'
    })
    melange_student2 = profile_model.Profile(**student_properties)
    melange_student2.put()

    proposal_properties = {
        'parent': melange_student.key.to_old_key(),
        'program': gsoc2014,
        'title': 'test proposal',
        'abstract': 'test abstract',
        'content': 'test content',
        'mentor': profile.key.to_old_key(),
        'status': 'accepted',
        'has_mentor': True,
        'org': ndb_orgs[0].key.to_old_key(),
        'possible_mentors': [profile.key.to_old_key()]
    }
    melange_proposal = GSoCProposal(**proposal_properties)
    melange_proposal.put()

    project_properties = {
        'title': 'test project',
        'abstract': 'test abstract',
        'status': 'accepted',
        'parent': melange_student.key.to_old_key(),
        'mentors': [profile.key.to_old_key()],
        'program': gsoc2014,
        'org': ndb_orgs[0].key.to_old_key(),
        'proposal': melange_proposal.key(),
    }
    melange_project = GSoCProject(**project_properties)
    melange_project.put()
    ndb_orgs[1].slot_allocation = 1
    ndb_orgs[1].put()

    student_data.number_of_projects = 1
    student_data.number_of_proposals = 1
    student_data.project_for_orgs = [ndb_orgs[1].key]

    melange_student.put()
    melange_student2.put()

    project_properties.update({
        'student': melange_student2,
        'title': 'test project2'
    })
    melange_project2 = GSoCProject(**project_properties)
    melange_project2.put()
    ndb_orgs[1].slot_allocation += 1
    ndb_orgs[1].put()

    student_id = 'student'
    student_properties.update({
        'id': gci2013.key().name() + '/' + student_id,
        'parent': student_user.key,
        'program': ndb.Key.from_old_key(gci2013.key()),
    })
    gci_student = profile_model.Profile(**student_properties)
    gci_student.put()

    score_properties = {
        'parent': gci_student.key.to_old_key(),
        'program': gci2013,
        'points': 5,
        'tasks': [gci_task.key()]
    }
    score = GCIScore(**score_properties)
    score.put()

    document_properties = {
        'key_name': 'site/site/home',
        'link_id': 'home',
        'scope': site,
        'prefix': 'site',
        'author': current_user.key.to_old_key(),
        'title': 'Home Page',
        'content': 'This is the Home Page',
        'modified_by': current_user.key.to_old_key(),
    }
    home_document = Document(**document_properties)
    home_document.put()

    document_properties = {
        'key_name': 'user/test/notes',
        'link_id': 'notes',
        'scope': current_user.key.to_old_key(),
        'prefix': 'user',
        'author': current_user.key.to_old_key(),
        'title': 'My Notes',
        'content': 'These are my notes',
        'modified_by': current_user.key.to_old_key(),
    }
    notes_document = Document(**document_properties)
    notes_document.put()

    site.home = home_document
    site.put()

    memcache.flush_all()

    return http.HttpResponse('Done')
Exemple #7
0
def seed(request, *args, **kwargs):
  """Seeds the datastore with some default values.
  """

  site_properties = {
      'key_name': 'site',
      'latest_gsoc': 'numenta/son2014',
      # 'latest_gci': 'numenta/gci2013',
      }
  site = Site(**site_properties)
  site.put()

  account = accounts.getCurrentAccount()

  if not account:
    account = users.User(email='*****@*****.**')

  user_properties = {
      'id': 'matt',
      'account_id': account.user_id(),
      'account': account,
      }
  current_user = user.User(**user_properties)
  current_user.put()

  group_properties = {
       'key_name': 'numenta',
       'link_id': 'numenta',
       'name': 'Numenta Inc.',
       'short_name': 'Numenta',
       'home_page': 'http://numenta.org',
       'email': '*****@*****.**',
       'description': 'This is the profile for Numenta.',
       'contact_street': '811 Hamilton St',
       'contact_city': 'Redwood City, CA',
       'contact_country': 'United States',
       'contact_postalcode': '94063',
       'phone': '6503698282',
       'status': 'active',
       }
  numenta = Sponsor(**group_properties)
  numenta.put()

  now = datetime.datetime.now()
  # before = now - datetime.timedelta(365)
  # after = now + datetime.timedelta(365)
  # past_before = before - datetime.timedelta(2 * 365)
  # past_after = after - datetime.timedelta(2 * 365)

  # first_day = datetime.datetime(2014, 5, 1)
  # last_day = datetime.datetime(2014, 9, 1)
  # signup_deadline = first_day + datetime.timedelta(30)
  # signup_start = first_day
  # students_announced = signup_deadline + datetime.timedelta(15)
  program_start = datetime.datetime(2014, 3, 5)
  program_end = datetime.datetime(2014, 9, 1)

  timeline_properties = {
      'key_name': 'numenta/son2014',
      'link_id': 'son2014',
      'scope': numenta,

      'program_start': program_start,
      'program_end': program_end,

      'accepted_organization_announced_deadline': datetime.datetime(2014, 3, 1),
      'accepted_students_announced_deadline' : datetime.datetime(2014, 4, 15),

      'student_signup_start': datetime.datetime(2014, 3, 5),
      'student_signup_end': datetime.datetime(2014, 4, 1),

      'application_review_deadline': datetime.datetime(2014, 4, 10),

      'form_submission_start': datetime.datetime(2014, 3, 5),

      'student_application_matched_deadline': datetime.datetime(2014, 4, 12),

      'bonding_start': datetime.datetime(2014, 4, 15),
      'bonding_end': datetime.datetime(2014, 5, 1),

      'coding_start': datetime.datetime(2014, 5, 1),
      'coding_end': datetime.datetime(2014, 8, 1),

  }
  son2014_timeline = GSoCTimeline(**timeline_properties)
  son2014_timeline.put()

  program_properties = {
      'key_name': 'numenta/son2014',
      'link_id': 'son2014',
      'program_id': 'son2014',
      'sponsor': numenta,
      'scope': numenta,
      'name': 'Numenta Season of NuPIC 2014',
      'short_name': 'SoN 2014',
      'description': 'This is the program for SoN 2014.',
      'apps_tasks_limit': 42,
      'slots': 42,
      'timeline': son2014_timeline,
      'status': program_model.STATUS_VISIBLE,
      }
  son2014 = GSoCProgram(**program_properties)
  son2014.put()

  # timeline_properties.update({
  #     'key_name': 'numenta/gsoc2010',
  #     'link_id': 'gsoc2010',
  #     'program_start': past_before,
  #     'program_end': past_after,
  #     'accepted_organization_announced_deadline': past_before,
  #     'accepted_students_announced_deadline' : past_after,
  #     'student_signup_start': past_before,
  #     'student_signup_end': past_after,
  #     'application_review_deadline': past_after,
  #     'student_application_matched_deadline': past_after,
  #     'accepted_students_announced_deadline': past_after,
  #     'form_submission_start': past_before,
  # })
  # gsoc2010_timeline = GSoCTimeline(**timeline_properties)
  # gsoc2010_timeline.put()

  # program_properties.update({
  #     'key_name': 'numenta/gsoc2010',
  #     'link_id': 'gsoc2010',
  #     'program_id': 'gsoc2010',
  #     'name': 'Numenta Season of NuPIC 2010',
  #     'description': 'This is the program for GSoC 2010.',
  #     'short_name': 'GSoC 2010',
  #     'timeline': gsoc2010_timeline,
  # })
  # gsoc2010 = GSoCProgram(**program_properties)
  # gsoc2010.put()

  # TODO(drew): Replace son2014.prefix with whatever its replacement becomes
  # once prefix is removed from program and no longer used in the query for
  # OrgAppSurvey in soc.views.helper.RequestData._getProgramWideFields().
  org_app_survey_properties = {
    'key_name' : '%s/%s/orgapp' % (son2014.prefix, son2014.key().name()),
    'program' : son2014,
    'title' : 'Org App Survey',
    'content' : 'Here is some content.',
    'modified_by' : current_user.key.to_old_key(),
    'survey_start' : program_start,
    'survey_end' : program_end
  }
  org_app_survey_model.OrgAppSurvey(**org_app_survey_properties).put()

  org_app_survey_properties['key_name'] = ('%s/%s/orgapp' % (
      son2014.prefix, son2014.key().name()))
  org_app_survey_properties['program'] = son2014
  org_app_survey_properties['survey_start'] = program_start
  org_app_survey_properties['survey_end'] = program_end
  org_app_survey_model.OrgAppSurvey(**org_app_survey_properties).put()

  # timeline_properties = {
  #       'key_name': 'numenta/gci2013',
  #       'link_id': 'gci2013',
  #       'scope': numenta,
  #       'program_start': before,
  #       'program_end': after,
  #       'accepted_organization_announced_deadline': before,
  #       'student_signup_start': before,
  #       'student_signup_end': after,
  #       'tasks_publicly_visible': before,
  #       'task_claim_deadline': after,
  #       'stop_all_work_deadline': after,
  # }
  # gci2013_timeline = GCITimeline(**timeline_properties)
  # gci2013_timeline.put()

  # program_properties.update({
  #     'key_name': 'numenta/gci2013',
  #     'link_id': 'gci2013',
  #     'program_id': 'gci2013',
  #     'name': 'Numenta Code In Contest 2013',
  #     'short_name': 'GCI 2009',
  #     'description': 'This is the program for GCI 2013.',
  #     'timeline': gci2013_timeline,
  #     })
  # gci2013 = GCIProgram(**program_properties)
  # gci2013.put()

  # site.active_program = gci2013
  site.active_program = son2014
  site.put()

  current_user.host_for = [
      # ndb.Key.from_old_key(gsoc2010.key()),
      ndb.Key.from_old_key(son2014.key()),
      # ndb.Key.from_old_key(gci2013.key())
  ]
  current_user.put()

  # group_properties.update({
  #   'key_name': 'numenta/gci2013/melange',
  #   'link_id': 'melange',
  #   'name': 'Melange Development Team',
  #   'short_name': 'Melange',
  #   'scope': gci2013,
  #   'program': gci2013,
  #   'sponsor': numenta,
  #   'home_page': 'http://code.numenta.com/p/soc',
  #   'description': 'Melange, share the love!',
  #   'license_name': 'Apache License',
  #   'ideas': 'http://code.numenta.com/p/soc/issues',
  #   })
  # melange = GCIOrganization(**group_properties)
  # melange.put()

  group_properties.update({
    'scope': son2014,
    'program': son2014,
    })

  address_properties = address.Address(
      street='942 Brookgrove Ln',
      city='Cupertino, CA',
      country='United States',
      postal_code='95014')
  address_properties.put()

  contact_info = contact.Contact(email='*****@*****.**')
  contact_info.put()

  gsoc_delta = datetime.timedelta(days=(365 * 18))

  profile_properties = {
      'id': son2014.key().name() + '/' + current_user.key.id(),
      'parent': current_user.key,
      'public_name': 'Matt Taylor',
      'program': ndb.Key.from_old_key(son2014.key()),
      'first_name': 'Matthew',
      'last_name': 'Taylor',
      'contact' : contact_info,
      'residential_address' : address_properties,
      'shipping_address' : address_properties,
      'birth_date' : datetime.datetime(1978, 7, 11),
      'program_knowledge' : 'Creator',
      }
  profile = profile_model.Profile(**profile_properties)

  # ndb_orgs = []
  # for i in range(2):
  group_properties.update({
      'key_name': 'numenta/son2014/numenta_org',
      'link_id': 'numenta_org',
      'name': 'Numenta Inc.',
      'short_name': 'Numenta',
      'description': 'This is the organization for Numenta, Inc.',
      })

  org_properties = {
      'name': 'Numenta Inc.',
      'org_id': 'numenta_org',
      'program': ndb.Key.from_old_key(son2014.key()),
      'description': 'This is the organization for Numenta, Inc.',
      }
  org = soc_org_model.SOCOrganization(
      id='numenta/son2014/numenta_org', **org_properties)
  org.put()

  profile.admin_for.append(org.key)
  profile.mentor_for.append(org.key)
  profile.put()

  # profile_properties.update({
  #     'id': son2014.key().name() + '/' + current_user.key.id(),
  #     'parent': current_user.key,
  #     'program': ndb.Key.from_old_key(son2014.key()),
  #     'admin_for': [ndb.Key.from_old_key(son2014.key())],
  #     'mentor_for': [ndb.Key.from_old_key(son2014.key())],
  #     })
  # numenta_admin = profile_model.Profile(**profile_properties)
  # # TODO: add GCI orgs
  # numenta_admin.put()

  # task_properties = {
  #     'status': 'Open',
  #     'modified_by': numenta_admin.key.to_old_key(),
  #     'subscribers': [numenta_admin.key.to_old_key()],
  #     'title': 'Awesomeness (test task)',
  #     'created_by': numenta_admin.key.to_old_key(),
  #     'created_on': now,
  #     'program': son2014,
  #     'time_to_complete': 1337,
  #     'modified_on': now,
  #     'org': org.key,
  #     'description': '<p>AWESOME</p>',
  #     'difficulty_level': DifficultyLevel.MEDIUM,
  #     'types': ['Code']
  # }
  # gci_task = GCITask(**task_properties)
  # gci_task.put()

  user_properties = {
      'id': 'student',
      'account_id': '12345',
      'account': users.User(email='*****@*****.**'),
      }
  student_user = user.User(**user_properties)
  student_user.put()

  gci_delta = datetime.timedelta(days=(365 * 14))

  contact_properties = contact.Contact(
      email='*****@*****.**',
      web_page='http://www.homepage.com/',
      blog='http://www.blog.com/',
      phone='1650253000')
  contact_properties.put()

  graduation_year = datetime.date.today() + datetime.timedelta(days=365)

  student_data = soc_profile.SOCStudentData(
      education=education.Education(
          school_id="123",
          school_country="United States",
          expected_graduation=int(graduation_year.strftime('%Y')),
          major='Some Major',
          degree=education.Degree.UNDERGRADUATE)
      )
  student_data.put()

  student_id = 'student'
  student_properties = {
      'id': son2014.key().name() + "/" + student_id,
      'parent': student_user.key,
      'program': ndb.Key.from_old_key(son2014.key()),
      'public_name': 'Student',
      'first_name': 'Student',
      'last_name': 'Student',
      'contact' : contact_properties,
      'residential_address' : address_properties,
      'shipping_address' : address_properties,
      'birth_date': datetime.date.today() - gci_delta,
      'tee_size': profile_model.TeeSize.L,
      'tee_style': profile_model.TeeStyle.MALE,
      'gender' : profile_model.Gender.MALE,
      'program_knowledge': 'Friend referral.',
      'student_data' : student_data,
      }
  nupic_student = profile_model.Profile(**student_properties)
  nupic_student.put()

  student_id = 'student2'
  user_properties = {
      'id': student_id,
      'account_id': 'student2',
      'account': users.User(email='*****@*****.**'),
      }
  student_user2 = user.User(**user_properties)
  student_user2.put()

  student_properties.update({
      'id': son2014.key().name() + "/" + student_id,
      'parent': student_user2.key,
      'first_name' : 'Student 2',
      'last_name' : 'Example'
  })
  nupic_student2 = profile_model.Profile(**student_properties)
  nupic_student2.put()

  proposal_properties = {
      'parent': nupic_student.key.to_old_key(),
      'program': son2014,
      'title': 'test proposal',
      'abstract': 'test abstract',
      'content': 'test content',
      'mentor': profile.key.to_old_key(),
      'status': 'accepted',
      'has_mentor': True,
      'org': org.key.to_old_key(),
      'possible_mentors': [profile.key.to_old_key()]
      }
  nupic_proposal = GSoCProposal(**proposal_properties)
  nupic_proposal.put()

  project_properties = {
      'title': 'NuPIC test project 1',
      'abstract': 'test abstract',
      'status': 'accepted',
      'parent': nupic_student.key.to_old_key(),
      'mentors': [profile.key.to_old_key()],
      'program':  son2014,
      'org': org.key.to_old_key(),
      'proposal' : nupic_proposal.key(),
       }
  nupic_project = GSoCProject(**project_properties)
  nupic_project.put()
  org.slot_allocation = 1
  org.put()

  student_data.number_of_projects = 1
  student_data.number_of_proposals = 1
  student_data.project_for_orgs = [org.key]

  nupic_student.put()
  nupic_student2.put()

  project_properties.update({
      'student': nupic_student2,
      'title': 'NuPIC test project 2'
      })
  nupic_project2 = GSoCProject(**project_properties)
  nupic_project2.put()
  org.slot_allocation += 1
  org.put()

  # student_id = 'student'
  # student_properties.update({
  #     'id': son2014.key().name() + '/' + student_id,
  #     'parent': student_user.key,
  #     'program': ndb.Key.from_old_key(son2014.key()),
  # })
  # gci_student = profile_model.Profile(**student_properties)
  # gci_student.put()

  # score_properties = {
  #     'parent': gci_student.key.to_old_key(),
  #     'program': gci2013,
  #     'points': 5,
  #     'tasks': [gci_task.key()]
  #     }
  # score = GCIScore(**score_properties)
  # score.put()

  document_properties = {
      'key_name': 'site/site/home',
      'link_id': 'home',
      'scope': site,
      'prefix': 'site',
      'author': current_user.key.to_old_key(),
      'title': 'Home Page',
      'content': 'This is the Home Page',
      'modified_by': current_user.key.to_old_key(),
      }
  home_document = Document(**document_properties)
  home_document.put()

  document_properties = {
      'key_name': 'user/test/notes',
      'link_id': 'notes',
      'scope': current_user.key.to_old_key(),
      'prefix': 'user',
      'author': current_user.key.to_old_key(),
      'title': 'My Notes',
      'content': 'These are my notes',
      'modified_by': current_user.key.to_old_key(),
      }
  notes_document = Document(**document_properties)
  notes_document.put()

  site.home = home_document
  site.put()

  memcache.flush_all()

  return http.HttpResponse('Done')