The way to provide authorization for this wrapper is to provide cookies from an active WebReg session (i.e., your authentication cookies).

To get your authentication cookies, you'll need to do the following: - Log into WebReg. - Select a term in the WebReg main menu. - Open Developer Tools (With Google Chrome, go to the three dots, "More tools," and then "Developer tools.") - Go to the "Network" tab of the Developer Tools. Then, either: - Filter by the text https://act.ucsd.edu/webreg2/svc/wradapter - OR, filter by Fetch/XHR. - Make some sort of request on WebReg (e.g., searching a course). - Look for a request made by WebReg. - Under the request headers, copy the cookie.

Keep in mind that your cookies will expire after either: - 10 minutes of inactivity (i.e., you do not make some request that uses your cookies for more than 10 minutes), or - when WebReg goes into maintenance mode; this occurs daily at around 4:15AM pacific time.

Thus, you will need to find some way to keep yourself logged into WebReg 24/7 if you want to perform continuous requests.

To use the wrapper, you need to create a new instance of it. For example: ```rs use reqwest::Client; use webweg::wrapper::WebRegWrapper;

let term = "SP22"; // For authentication cookies, see previous section. let cookie = "your authentication cookies here"; let w = WebRegWrapper::new(Client::new(), cookie.to_string(), term); `` For your convenience,reqwestis automatically exported so you can use that fromwebweg`.

Once created, you're able to use the various wrapper functions. Some useful examples are shown below (note that w refers to the declaration above).

Most wrapper functions will return a Result<T, Error>, where T is the result type. So, if a request is successful, you'll get T back. If the request is unsuccessful, you will get back an Error, which contains information about why the request failed.

Check Login Status

You can check to see if you are logged in (i.e., if the wrapper can actually perform any useful requests). rs if !w.is_valid().await { eprintln!("You aren't logged in!"); return; }

Get Schedule

You can get your current schedule, which lists your Enrolled, Planned, and Waitlisted courses. You are able to fetch either the default schedule (None) or a specific schedule (e.g., My Schedule 2)

Example: Suppose you wanted to see what courses are currently in your default schedule. We can use the following code:

rs let my_schedule = w.get_schedule(None).await; match my_schedule { Ok(s) => s.into_iter().for_each(|p| println!("{}", p.to_string())), Err(e) => eprintln!("{}", e), };

Remark: If you wanted to see what courses you have planned in some other schedule, you can replace None with Some("your schedule name here").

Get Course Information

You are able to search up course information for a particular course. If no issues occur, then this function will return a vector where each element contains the instructor name, number of seats, and all meetings.

Example: Suppose we wanted to look up all CSE 101 sections. We can use the following code:

rs let courses_101 = w.get_course_info("CSE", "101").await; match courses_101 { Ok(s) => s.into_iter().for_each(|p| println!("{}", p.to_string())), Err(e) => eprintln!("{}", e), };

Search Courses

You can also search up courses that meet a particular criteria. This is very similar in nature to the Advanced Search option.

Example 1: Suppose we wanted to search for specific sections. In our example below, we'll search for one section of CSE 100, one section of Math 184, and one section of POLI 28 (for Winter 2022). The following code will do just that:

```rs use webweg::wrapper::SearchType;

let searchres = w .searchcoursesdetailed(SearchType::ByMultipleSections(&[ "079913", "078616", "075219", ])) .await; match searchres { Ok(s) => s.intoiter().foreach(|p| println!("{}", p.to_string())), Err(e) => eprintln!("{}", e), }; ```

Example 2: Suppose we wanted to search for any lower- or upper-division CSE course. We can use the following code:

```rs use webweg::wrapper::{CourseLevelFilter, SearchRequestBuilder};

let searchres = w .searchcoursesdetailed(SearchType::Advanced( SearchRequestBuilder::new() .adddepartment("CSE") .filtercoursesby(CourseLevelFilter::UpperDivision) .filtercoursesby(CourseLevelFilter::LowerDivision), )) .await; match searchres { Ok(s) => s.intoiter().foreach(|p| println!("{}", p.tostring())), Err(e) => eprintln!("{}", e), }; ```

Planning & Un-planning a Section

You can use the wrapper to plan a section, adding it to your schedule.

Example 1: Suppose you wanted to plan a section of CSE 100 to your default schedule. You can use the following code:

rs let res = w.add_to_plan(PlanAdd { subject_code: "CSE", course_code: "100", section_id: "079911", section_code: "A01", // Using S/U grading. grading_option: Some(GradeOption::S), // Put in default schedule schedule_name: None, unit_count: 4 }, true).await; match res { Ok(o) => println!("{}", if o { "Successful" } else { "Unsuccessful" }), Err(e) => eprintln!("{}", e), };

Example 2: Suppose you want to remove the section of CSE 100 from your default schedule. You can use the following code:

rs let res = w.remove_from_plan("079911", None).await; match res { Ok(o) => println!("{}", if o { "Successful" } else { "Unsuccessful" }), Err(e) => eprintln!("{}", e), };

Remark: If you wanted to add (or remove) this section to (from) a different schedule, you can do so by replacing None with Some("your schedule name here").

Enrolling & Waitlisting Sections

You can also use the wrapper to programmatically enroll or waitlist particular sections.

Example: Suppose we wanted to enroll or waitlist a section of Math 184 with section number 078616, and then drop it afterwards. This is how we could do this.

```rs use std::time::Duration; use webweg::types::EnrollmentStatus; use webweg::wrapper::EnrollWaitAdd;

let sectionres = w .searchcoursesdetailed(SearchType::BySection("078616")) .await .unwraporelse(|| vec![]);

if sectionres.isempty() { eprintln!("No section found."); return; }

let addres = w .addsection( sectionres[0].hasseats(), EnrollWaitAdd { sectionid: "078616", // Use default grade option gradingoption: None, // Use default unit count unit_count: None, }, // Validate our request with WebReg true, ) .await;

match add_res { Ok(o) => println!("{}", if o { "Successful" } else { "Unsuccessful" }), Err(e) => { eprintln!("{}", e); return; } };

// Wait a bit, although this is unnecessary. std::thread::sleep(Duration::from_secs(2));

// Get your current schedule let coursetodrop = w .getschedule(None) .await .unwraporelse(|| vec![]) .intoiter() .find(|x| x.sectionid == 78616);

// Check if we're enrolled in this course let isenrolled = if let Some(r) = coursetodrop { match r.enrolledstatus { EnrollmentStatus::Enrolled => true, _ => false, } } else { eprintln!("Course not enrolled or waitlisted."); return; };

// Drop the class. let remres = w.dropsection(is_enrolled, "078616").await;

match rem_res { Ok(o) => println!("{}", if o { "Successful" } else { "Unsuccessful" }), Err(e) => eprintln!("{}", e), }; ```