def test_duplicate_courses_skipped(self, mock_catalog_course_runs):
mock_catalog_course_runs.return_value = self.catalog_course_runs
initial_display_name = "Test duplicated course"
course_run = self.catalog_course_runs[0]
course_key = CourseKey.from_string(course_run.get('key'))
create_new_course_in_store(ModuleStoreEnum.Type.split, self.user,
course_key.org, course_key.course,
course_key.run,
{"display_name": initial_display_name})
with LogCapture() as capture:
call_command('sync_courses', self.user.email)
expected_message = u"Course already exists for {}, {}, {}. Skipping".format(
course_key.org,
course_key.course,
course_key.run,
)
capture.check_present(
(COMMAND_MODULE, 'WARNING', expected_message))
self._validate_courses()
course = modulestore().get_course(course_key)
self.assertEqual(course.display_name, initial_display_name)
def handle(self, *args, **options):
"""Execute the command"""
instructor = self.get_user(options['instructor'])
course_runs = get_course_runs()
for course_run in course_runs:
course_key = CourseKey.from_string(course_run.get('key'))
fields = {
"display_name": course_run.get('title')
}
try:
new_course = create_new_course_in_store(
ModuleStoreEnum.Type.split,
instructor,
course_key.org,
course_key.course,
course_key.run,
fields,
)
logger.info(u"Created {}".format(text_type(new_course.id)))
except DuplicateCourseError:
logger.warning(
u"Course already exists for %s, %s, %s. Skipping",
course_key.org,
course_key.course,
course_key.run,
)
def handle(self, *args, **options):
run = options['run']
org = options['org']
name = options['name']
number = options['number']
storetype = options['modulestore']
start_date = options["start_date"]
user = self.get_user(options['user'])
# start date is set one week ago if not given
start_date = datetime.strptime(
start_date,
"%Y-%m-%d") if start_date else datetime.now() - timedelta(days=7)
if storetype == ModuleStoreEnum.Type.mongo:
self.stderr.write(
"WARNING: The 'Old Mongo' store is deprecated. New courses should be added to split."
)
fields = {"start": start_date}
if name:
fields["display_name"] = name
try:
new_course = create_new_course_in_store(storetype, user, org,
number, run, fields)
self.stdout.write(f"Created {str(new_course.id)}")
except DuplicateCourseError:
self.stdout.write("Course already exists")
def handle(self, *args, **options):
try:
courses = json.loads(options["courses_json"])["courses"]
except ValueError:
raise CommandError("Invalid JSON object") # lint-amnesty, pylint: disable=raise-missing-from
except KeyError:
raise CommandError("JSON object is missing courses list") # lint-amnesty, pylint: disable=raise-missing-from
for course_settings in courses:
# Validate course
if not self._course_is_valid(course_settings):
logger.warning(
"Can't create course, proceeding to next course")
continue
# Retrieve settings
org = course_settings["organization"]
num = course_settings["number"]
run = course_settings["run"]
user_email = course_settings["user"]
try:
user = user_from_str(user_email)
except User.DoesNotExist:
logger.warning(user_email + " user does not exist") # lint-amnesty, pylint: disable=logging-not-lazy
logger.warning(
"Can't create course, proceeding to next course")
continue
fields = self._process_course_fields(course_settings["fields"])
# Create the course
try:
new_course = create_new_course_in_store(
"split", user, org, num, run, fields)
logger.info(f"Created {str(new_course.id)}")
except DuplicateCourseError:
logger.warning("Course already exists for %s, %s, %s", org,
num, run)
# Configure credit provider
if ("enrollment"
in course_settings) and ("credit_provider"
in course_settings["enrollment"]):
credit_provider = course_settings["enrollment"][
"credit_provider"]
if credit_provider is not None:
CreditProvider.objects.get_or_create(
provider_id=credit_provider,
display_name=credit_provider)
def post(self, request, course_key_string):
course_key = CourseKey.from_string(course_key_string)
# Create the course
try:
user = User.objects.get(username=USERNAME)
course_name = request.data.get("name", "Empty")
fields = {"display_name": course_name}
new_course = create_new_course_in_store("split", user,
course_key.org,
course_key.course,
course_key.run, fields)
msg = u"Created {}".format(new_course.id)
log.info(msg)
self.finalize_course(course_key)
return Response({'detail': msg})
except DuplicateCourseError:
msg = u"Course already exists for {}, {}, {}".format(
course_key.org, course_key.course, course_key.run)
log.warning(msg)
raise ParseError(msg)
