Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2023 - E2360. View for Results of Bidding (Phase2)

2023-12-14T20:39:33Z

Schen76: /* Testing */

== Motivation ==

The bidding view is needed because we don’t have a way of finding out whether the bidding algorithm is running correctly. This project is to add a bidding view to show how the topics are assigned to those teams who bid.

== Work Plan ==

Based on the project's objectives and feedback received from our mentor, we have identified specific areas for improvement:

1) Refactor variable names within methods such as "bidding_details" and variables like "Topic name" and "Bidding teams" to enhance clarity and specificity.

2) Adjust capitalization for certain components, ensuring that only the first word is capitalized for consistency.

3) Introduce calculations to determine percentages based on additional data, such as the total number of teams and the number of teams for each priority, within the "lottery_controller."

4) Conduct thorough testing of the modified controller and view to ensure optimal functionality.

[[File:Newfeature.jpg | 888px]]

To add functionality for showing the percentages of the number of teams that got their #1, #2, and #3 choices. We can follow these high-level steps:

'''Lottery_Controller:'''

i) Compute the Total Number of Teams: Before we can compute percentages, we need to know the total number of teams that participated in the bidding process. This will be our denominator in the percentage calculation.

ii) Compute the Number of Teams for Each Priority: From our `bidding_details` method, we already have counts for how many teams bid on each topic as their #1, #2, and #3 choice (`@count1`, `@count2`, `@count3`). However, these counts are currently organized by topic. We would need to modify this to count how many teams got their #1, #2, and #3 choices as their assigned topic.

iii) Compute Percentages: Once we have the number of teams that got their #1, #2, and #3 choices, we can compute the percentages by dividing these numbers by the total number of teams and multiplying by 100.

'''Bidding_detail view:'''

i) Update the View and Display Percentages: Above the table in our previous view, we can add a section to display these percentages.

ii) Format the Display: We will use a bold heading for each percentage type and format the number to a fixed number of decimal places.

iii) Ensure Responsiveness: Make sure the display of these percentages adjusts well to different screen sizes, maintaining readability and layout consistency.

== Code Effort ==

Change in <code> app/controllers/lottery_controller.rb </code>

'''method 1: bidding_table_for_topics'''

This method generates a bidding table for each topic within an assignment. It performs several operations to gather and organize data related to topics, bids, and teams. Here's a breakdown of what the code does:

1. Fetch Assignment:

*It retrieves the assignment with the specified params[:id] from the database and stores it in the @assignment instance variable.

2. Fetch Topics:

*It retrieves all sign-up topics associated with the assignment and stores them in the @topics instance variable.

3. Fetch Bids and Assigned Teams:

For each topic in @topics, it:
*Retrieves all bids associated with that topic and stores them in a hash, where the key is the topic's ID and the value is an array of bids with their associated teams and priorities.
*Retrieves teams that are not waitlisted for the topic and stores them in a hash, again using the topic's ID as the key and an array of teams as the value.

4. Priority Count Calculation:

*It dynamically computes and updates the counts for each bid priority level (1, 2, and 3) for each topic. These counts are stored in instance variables named @count1, @count2, and @count3. These instance variables are hashes where the keys are topic IDs, and the values are counts for each priority level.

5. Computes Total Teams:

*It determines the total number of teams across all topics in the assignment by counting distinct team IDs among all non-waitlisted teams for the specified topics.

6. Computes Priority Counts and Percentages:

*It calls two helper methods, compute_priority_counts and compute_percentages, to compute the total counts of teams at each priority level and the corresponding percentages. The results are stored in the @priority_counts and @percentages instance variables, respectively.

<pre>
# Prepares data for displaying the bidding details for each topic within an assignment.
# It computes the number of bids for each priority (1, 2, 3) per topic and also computes
# the overall percentages of teams that received their first, second, and third choice.
def bidding_table_for_topics
@assignment = Assignment.find(params[:id])
# Fetch all topics for the assignment
@topics = @assignment.sign_up_topics
# Fetch all bids for these topics
@bids_by_topic = {}
@assigned_teams_by_topic = {} # This will store the assigned teams for each topic
@topics.each do |topic|
# Assuming bids are stored with a topic_id, and each bid has a team associated with it
@bids_by_topic[topic.id] = Bid.where(topic_id: topic.id).map { |bid| { team: bid.team, priority: bid.priority } }
# Fetch teams that are not waitlisted for this topic
@assigned_teams_by_topic[topic.id] = SignedUpTeam.where(topic_id: topic.id, is_waitlisted: false).map(&:team)
# Dynamically initializing and updating @count1, @count2, and @count3
(1..3).each do |priority|
instance_variable_set("@count#{priority}", Hash.new(0)) unless instance_variable_defined?("@count#{priority}")
instance_variable_get("@count#{priority}")[topic.id] = @bids_by_topic[topic.id].count { |bid| bid[:priority] == priority }
end
end
# Computes the total number of teams and percentages after fetching bid details
topic_ids = SignUpTopic.where(assignment_id: @assignment.id).pluck(:id)
@total_teams = SignedUpTeam.where(topic_id: topic_ids).distinct.count(:team_id)
@priority_counts = compute_priority_counts(@assigned_teams_by_topic, @bids_by_topic)
@percentages = compute_percentages(@priority_counts, @total_teams)

end
</pre>

'''method 2: compute_priority_counts'''

1. Parameters
*assigned_teams_by_topic (Hash): A hash mapping each topic to an array of assigned teams.
*bids_by_topic (Hash): A hash mapping each topic to an array of bid objects, where each bid object is a hash containing team and priority information.

2. Functionality
*Initial Setup: Initializes a hash priority_counts with keys 1, 2, and 3, each having an initial value of 0. These keys represent the priority levels, and their values count the number of teams assigned to each level.

*Iterating Over Topics and Teams: Iterates over each topic and its associated teams found in assigned_teams_by_topic. For each team in a topic, the method searches bids_by_topic[topic_id] to find a bid made by the team.

*Updating Priority Counts: If a bid is found, the method increments the count in priority_counts corresponding to the priority level in the bid. This process effectively tallies the number of teams assigned to each priority level.

3. Returns
*priority_counts (Hash): A hash with keys 1, 2, and 3, where each key's value represents the count of teams assigned to that respective priority level.

<pre>
# Computes the count of assigned teams for each priority level (1, 2, 3) across all topics.
# It checks each team associated with a topic and determines if the team's bid matches
# one of the priority levels, incrementing the respective count if so.
def compute_priority_counts(assigned_teams_by_topic, bids_by_topic)
priority_counts = { 1 => 0, 2 => 0, 3 => 0 }
assigned_teams_by_topic.each do |topic_id, teams|
teams.each do |team|
bid_info = bids_by_topic[topic_id].find { |bid| bid[:team] == team }
priority_counts[bid_info[:priority]] += 1 if bid_info
end
end
priority_counts
end
</pre>

'''method 3: compute_percentages'''

* This method computes the percentages of teams that received their first, second, and third choice based on the counts of teams at each priority level.

<pre>
# Computes the percentages of teams that received their first, second, and third choice
# based on the counts of teams at each priority level.
def compute_percentages(priority_counts, total_teams)
priority_counts.transform_values { |count| (count.to_f / total_teams * 100).round(2) }
end
</pre>

Change in <code> app/views/lottery/bidding_table_for_topics.html.erb </code>

[[File:bidding_percentage.png | 888px]]

Components:

1. Percentage Display Section

*This section is styled with a border, padding, and a background color to make it visually distinct.
*It contains a subtitle (h4) describing the content: "Percentage of Teams Getting Their Choices."
*A list (ul) displays the percentages of teams that received their 1st, 2nd, and 3rd choice. These percentages are pulled dynamically from @percentages array.
*The colors of the percentage values vary based on the choice priority (green for #1, orange for #2, and red for #3).
Custom CSS Styles

2. Bidding Details Table

*A table with headers for Topic ID, Topic Name, Bidding Teams, and bids.
*The table body (<tbody>) dynamically generates rows for each topic using a loop (<% @topics.each do |topic| %>).
*For each topic, the table displays its name, ID, bidding teams, and the number of bids for each choice.
*Teams are marked with the .assigned-team class if they are assigned to the topic.
*Bid counts are displayed, with a placeholder ("–") if the count is zero.

<pre>
<table class="table table-bordered table-hover">
<thead>
<tr>
<th>Topic id</th>
<th>Topic name</th>
<th>Bidding teams</th>
<th>#1 bids</th>
<th>#2 bids</th>
<th>#3 bids</th>
</tr>
</thead>
<tbody>
<% @topics.each do |topic| %>
<tr>
<td><%= topic.id %></td>
<td><%= topic.topic_name %></td>
<td class="teams-column">
<% @bids_by_topic[topic.id].each do |bid_info| %>
<% team = bid_info[:team] %>
<% assigned_team = @assigned_teams_by_topic[topic.id].include?(team) %>
<span class="<%= assigned_team ? 'assigned-team' : '' %>">
<%= team.name %> (#<%= bid_info[:priority] %>)
</span>
<% end %>
</td>
<td class="bids-column">
<% if @count1[topic.id] != 0%>
<%= @count1[topic.id] %>
<%else%>
–
<%end%>
</td>
<td class="bids-column">
<% if @count2[topic.id] != 0%>
<%= @count2[topic.id] %>
<%else%>
–
<%end%>
</td>
<td class="bids-column">
<% if @count3[topic.id] != 0%>
<%= @count3[topic.id] %>
<%else%>
–
<%end%>
</td>
</tr>
<% end %>
</tbody>
</table>

</pre>

== Testing ==

1. Test for Populating Bids and Assigned Teams:
*This test ensures that the bidding_table_for_each_topic method correctly populates bids and assigned teams for each topic.
*It checks if @bids_by_topic is populated correctly, verifying the length of bids for specific topics.
*It tests @assigned_teams_by_topic, ensuring it handles cases where topics have no teams.

<pre>

it 'populates bids and assigned teams for each topic, handling topics with no teams' do
controller.bidding_table_for_each_topic
# Check if @bids_by_topic is populated correctly
expect(controller.instance_variable_get(:@bids_by_topic)[topic1.id].length).to eq(1)
expect(controller.instance_variable_get(:@bids_by_topic)[topic2.id].length).to eq(1)
# Check if @assigned_teams_by_topic is populated correctly, allowing for no teams
assigned_teams_topic1 = controller.instance_variable_get(:@assigned_teams_by_topic)[topic1.id]
if assigned_teams_topic1
expect(assigned_teams_topic1.length).to(satisfy { |value| (value == 0) || (value == 1) })
else
expect(assigned_teams_topic1).to be_nil
end
# Check the counts of bids for each priority level
# Ensure to adjust these based on what is set up in your test data
expect(controller.instance_variable_get(:@count1)[topic1.id]).to eq(1)
# assuming there is one bid with priority 1 for topic1
expect(controller.instance_variable_get(:@count2)[topic1.id]).to eq(0)
# assuming there are no bids with priority 2 for topic1
expect(controller.instance_variable_get(:@count3)[topic1.id]).to eq(0)
# assuming there are no bids with priority 3 for topic1
end

</pre>

2. Test for Fetching All Topics:
*This test verifies that all topics for the assignment are fetched and stored in @topics.

<pre>
it 'fetches all topics for the assignment' do
controller.bidding_table_for_each_topic
expect(controller.instance_variable_get(:@topics)).to match_array([topic1, topic2, topic3, topic4])
end
</pre>

3. Test for Computing Priority Counts:
*This test checks the calculation of priority counts for each topic.
*It compares the computed priority counts against an expected set of values.
*It verifies the priority count is computing the values precisely for topics.

<pre>
it 'correctly calculates priority counts for each topic' do
controller.bidding_table_for_each_topic

# Assuming you have a way to know the expected counts for each priority
expected_priority_counts = { 1 => 0,
2 => 0,
3 => 0 }

priority_counts = controller.instance_variable_get(:@priority_counts)
expect(priority_counts).to eq(expected_priority_counts)
end
</pre>

4. Test for Computing Percentages for Teams Getting Their Choices:
*This test ensures that the method correctly computes the percentages of teams getting their preferred choices.
*It handles special cases where the expected percentages are not a number (NaN).

<pre>
it 'correctly calculates percentages for teams getting their choices' do
controller.bidding_table_for_each_topic

# Assuming you have a way to know the expected percentages
expected_percentages = { 1 => Float::NAN,
2 => Float::NAN,
3 => Float::NAN }

percentages = controller.instance_variable_get(:@percentages)
expect(percentages[1].nan?).to be true if expected_percentages[1].nan?
expect(percentages[2].nan?).to be true if expected_percentages[2].nan?
expect(percentages[3].nan?).to be true if expected_percentages[3].nan?
end
</pre>

Rspec Testing <code> app/views/lottery/bidding_table_for_each_topic.html.erb </code>

== Relevant Links ==

'''Github Repository: ''' https://github.com/Shreshth-Malik/expertiza

'''Demo Video:''' https://www.youtube.com/watch?v=pGmHyqLj7PM

'''Pull Request:''' https://github.com/expertiza/expertiza/pull/2659

== Testing Credentials ==

username: instructor6

password: password

== Team ==
'''Mentor'''

Edward F. Gehringer (efg@ncsu.edu)

'''Members'''

Richard Li (rli14@ncsu.edu)

Shreshth Malik (smalik4@ncsu.edu)

Shuai Chen (schen76@ncsu.edu)

CSC/ECE 517 Fall 2023 - E2360. View for Results of Bidding (Phase2)

2023-12-14T20:38:34Z

Schen76: /* Work Plan */

== Motivation ==

The bidding view is needed because we don’t have a way of finding out whether the bidding algorithm is running correctly. This project is to add a bidding view to show how the topics are assigned to those teams who bid.

== Work Plan ==

Based on the project's objectives and feedback received from our mentor, we have identified specific areas for improvement:

1) Refactor variable names within methods such as "bidding_details" and variables like "Topic name" and "Bidding teams" to enhance clarity and specificity.

2) Adjust capitalization for certain components, ensuring that only the first word is capitalized for consistency.

3) Introduce calculations to determine percentages based on additional data, such as the total number of teams and the number of teams for each priority, within the "lottery_controller."

4) Conduct thorough testing of the modified controller and view to ensure optimal functionality.

[[File:Newfeature.jpg | 888px]]

To add functionality for showing the percentages of the number of teams that got their #1, #2, and #3 choices. We can follow these high-level steps:

'''Lottery_Controller:'''

i) Compute the Total Number of Teams: Before we can compute percentages, we need to know the total number of teams that participated in the bidding process. This will be our denominator in the percentage calculation.

ii) Compute the Number of Teams for Each Priority: From our `bidding_details` method, we already have counts for how many teams bid on each topic as their #1, #2, and #3 choice (`@count1`, `@count2`, `@count3`). However, these counts are currently organized by topic. We would need to modify this to count how many teams got their #1, #2, and #3 choices as their assigned topic.

iii) Compute Percentages: Once we have the number of teams that got their #1, #2, and #3 choices, we can compute the percentages by dividing these numbers by the total number of teams and multiplying by 100.

'''Bidding_detail view:'''

i) Update the View and Display Percentages: Above the table in our previous view, we can add a section to display these percentages.

ii) Format the Display: We will use a bold heading for each percentage type and format the number to a fixed number of decimal places.

iii) Ensure Responsiveness: Make sure the display of these percentages adjusts well to different screen sizes, maintaining readability and layout consistency.

== Code Effort ==

Change in <code> app/controllers/lottery_controller.rb </code>

'''method 1: bidding_table_for_topics'''

This method generates a bidding table for each topic within an assignment. It performs several operations to gather and organize data related to topics, bids, and teams. Here's a breakdown of what the code does:

1. Fetch Assignment:

*It retrieves the assignment with the specified params[:id] from the database and stores it in the @assignment instance variable.

2. Fetch Topics:

*It retrieves all sign-up topics associated with the assignment and stores them in the @topics instance variable.

3. Fetch Bids and Assigned Teams:

For each topic in @topics, it:
*Retrieves all bids associated with that topic and stores them in a hash, where the key is the topic's ID and the value is an array of bids with their associated teams and priorities.
*Retrieves teams that are not waitlisted for the topic and stores them in a hash, again using the topic's ID as the key and an array of teams as the value.

4. Priority Count Calculation:

*It dynamically computes and updates the counts for each bid priority level (1, 2, and 3) for each topic. These counts are stored in instance variables named @count1, @count2, and @count3. These instance variables are hashes where the keys are topic IDs, and the values are counts for each priority level.

5. Computes Total Teams:

*It determines the total number of teams across all topics in the assignment by counting distinct team IDs among all non-waitlisted teams for the specified topics.

6. Computes Priority Counts and Percentages:

*It calls two helper methods, compute_priority_counts and compute_percentages, to compute the total counts of teams at each priority level and the corresponding percentages. The results are stored in the @priority_counts and @percentages instance variables, respectively.

<pre>
# Prepares data for displaying the bidding details for each topic within an assignment.
# It computes the number of bids for each priority (1, 2, 3) per topic and also computes
# the overall percentages of teams that received their first, second, and third choice.
def bidding_table_for_topics
@assignment = Assignment.find(params[:id])
# Fetch all topics for the assignment
@topics = @assignment.sign_up_topics
# Fetch all bids for these topics
@bids_by_topic = {}
@assigned_teams_by_topic = {} # This will store the assigned teams for each topic
@topics.each do |topic|
# Assuming bids are stored with a topic_id, and each bid has a team associated with it
@bids_by_topic[topic.id] = Bid.where(topic_id: topic.id).map { |bid| { team: bid.team, priority: bid.priority } }
# Fetch teams that are not waitlisted for this topic
@assigned_teams_by_topic[topic.id] = SignedUpTeam.where(topic_id: topic.id, is_waitlisted: false).map(&:team)
# Dynamically initializing and updating @count1, @count2, and @count3
(1..3).each do |priority|
instance_variable_set("@count#{priority}", Hash.new(0)) unless instance_variable_defined?("@count#{priority}")
instance_variable_get("@count#{priority}")[topic.id] = @bids_by_topic[topic.id].count { |bid| bid[:priority] == priority }
end
end
# Computes the total number of teams and percentages after fetching bid details
topic_ids = SignUpTopic.where(assignment_id: @assignment.id).pluck(:id)
@total_teams = SignedUpTeam.where(topic_id: topic_ids).distinct.count(:team_id)
@priority_counts = compute_priority_counts(@assigned_teams_by_topic, @bids_by_topic)
@percentages = compute_percentages(@priority_counts, @total_teams)

end
</pre>

'''method 2: compute_priority_counts'''

1. Parameters
*assigned_teams_by_topic (Hash): A hash mapping each topic to an array of assigned teams.
*bids_by_topic (Hash): A hash mapping each topic to an array of bid objects, where each bid object is a hash containing team and priority information.

2. Functionality
*Initial Setup: Initializes a hash priority_counts with keys 1, 2, and 3, each having an initial value of 0. These keys represent the priority levels, and their values count the number of teams assigned to each level.

*Iterating Over Topics and Teams: Iterates over each topic and its associated teams found in assigned_teams_by_topic. For each team in a topic, the method searches bids_by_topic[topic_id] to find a bid made by the team.

*Updating Priority Counts: If a bid is found, the method increments the count in priority_counts corresponding to the priority level in the bid. This process effectively tallies the number of teams assigned to each priority level.

3. Returns
*priority_counts (Hash): A hash with keys 1, 2, and 3, where each key's value represents the count of teams assigned to that respective priority level.

<pre>
# Computes the count of assigned teams for each priority level (1, 2, 3) across all topics.
# It checks each team associated with a topic and determines if the team's bid matches
# one of the priority levels, incrementing the respective count if so.
def compute_priority_counts(assigned_teams_by_topic, bids_by_topic)
priority_counts = { 1 => 0, 2 => 0, 3 => 0 }
assigned_teams_by_topic.each do |topic_id, teams|
teams.each do |team|
bid_info = bids_by_topic[topic_id].find { |bid| bid[:team] == team }
priority_counts[bid_info[:priority]] += 1 if bid_info
end
end
priority_counts
end
</pre>

'''method 3: compute_percentages'''

* This method computes the percentages of teams that received their first, second, and third choice based on the counts of teams at each priority level.

<pre>
# Computes the percentages of teams that received their first, second, and third choice
# based on the counts of teams at each priority level.
def compute_percentages(priority_counts, total_teams)
priority_counts.transform_values { |count| (count.to_f / total_teams * 100).round(2) }
end
</pre>

Change in <code> app/views/lottery/bidding_table_for_topics.html.erb </code>

[[File:bidding_percentage.png | 888px]]

Components:

1. Percentage Display Section

*This section is styled with a border, padding, and a background color to make it visually distinct.
*It contains a subtitle (h4) describing the content: "Percentage of Teams Getting Their Choices."
*A list (ul) displays the percentages of teams that received their 1st, 2nd, and 3rd choice. These percentages are pulled dynamically from @percentages array.
*The colors of the percentage values vary based on the choice priority (green for #1, orange for #2, and red for #3).
Custom CSS Styles

2. Bidding Details Table

*A table with headers for Topic ID, Topic Name, Bidding Teams, and bids.
*The table body (<tbody>) dynamically generates rows for each topic using a loop (<% @topics.each do |topic| %>).
*For each topic, the table displays its name, ID, bidding teams, and the number of bids for each choice.
*Teams are marked with the .assigned-team class if they are assigned to the topic.
*Bid counts are displayed, with a placeholder ("–") if the count is zero.

<pre>
<table class="table table-bordered table-hover">
<thead>
<tr>
<th>Topic id</th>
<th>Topic name</th>
<th>Bidding teams</th>
<th>#1 bids</th>
<th>#2 bids</th>
<th>#3 bids</th>
</tr>
</thead>
<tbody>
<% @topics.each do |topic| %>
<tr>
<td><%= topic.id %></td>
<td><%= topic.topic_name %></td>
<td class="teams-column">
<% @bids_by_topic[topic.id].each do |bid_info| %>
<% team = bid_info[:team] %>
<% assigned_team = @assigned_teams_by_topic[topic.id].include?(team) %>
<span class="<%= assigned_team ? 'assigned-team' : '' %>">
<%= team.name %> (#<%= bid_info[:priority] %>)
</span>
<% end %>
</td>
<td class="bids-column">
<% if @count1[topic.id] != 0%>
<%= @count1[topic.id] %>
<%else%>
–
<%end%>
</td>
<td class="bids-column">
<% if @count2[topic.id] != 0%>
<%= @count2[topic.id] %>
<%else%>
–
<%end%>
</td>
<td class="bids-column">
<% if @count3[topic.id] != 0%>
<%= @count3[topic.id] %>
<%else%>
–
<%end%>
</td>
</tr>
<% end %>
</tbody>
</table>

</pre>

== Testing ==

1. Test for Populating Bids and Assigned Teams:
*This test ensures that the bidding_table_for_each_topic method correctly populates bids and assigned teams for each topic.
*It checks if @bids_by_topic is populated correctly, verifying the length of bids for specific topics.
*It tests @assigned_teams_by_topic, ensuring it handles cases where topics have no teams.

<pre>

it 'populates bids and assigned teams for each topic, handling topics with no teams' do
controller.bidding_table_for_each_topic
# Check if @bids_by_topic is populated correctly
expect(controller.instance_variable_get(:@bids_by_topic)[topic1.id].length).to eq(1)
expect(controller.instance_variable_get(:@bids_by_topic)[topic2.id].length).to eq(1)
# Check if @assigned_teams_by_topic is populated correctly, allowing for no teams
assigned_teams_topic1 = controller.instance_variable_get(:@assigned_teams_by_topic)[topic1.id]
if assigned_teams_topic1
expect(assigned_teams_topic1.length).to(satisfy { |value| (value == 0) || (value == 1) })
else
expect(assigned_teams_topic1).to be_nil
end
# Check the counts of bids for each priority level
# Ensure to adjust these based on what is set up in your test data
expect(controller.instance_variable_get(:@count1)[topic1.id]).to eq(1)
# assuming there is one bid with priority 1 for topic1
expect(controller.instance_variable_get(:@count2)[topic1.id]).to eq(0)
# assuming there are no bids with priority 2 for topic1
expect(controller.instance_variable_get(:@count3)[topic1.id]).to eq(0)
# assuming there are no bids with priority 3 for topic1
end

</pre>

2. Test for Fetching All Topics:
*This test verifies that all topics for the assignment are fetched and stored in @topics.

<pre>
it 'fetches all topics for the assignment' do
controller.bidding_table_for_each_topic
expect(controller.instance_variable_get(:@topics)).to match_array([topic1, topic2, topic3, topic4])
end
</pre>

3. Test for Calculating Priority Counts:
*This test checks the calculation of priority counts for each topic.
*It compares the calculated priority counts against an expected set of values.
*It verifies the priority count is computing the values precisely for topics.

<pre>
it 'correctly calculates priority counts for each topic' do
controller.bidding_table_for_each_topic

# Assuming you have a way to know the expected counts for each priority
expected_priority_counts = { 1 => 0,
2 => 0,
3 => 0 }

priority_counts = controller.instance_variable_get(:@priority_counts)
expect(priority_counts).to eq(expected_priority_counts)
end
</pre>

4. Test for Calculating Percentages for Teams Getting Their Choices:
*This test ensures that the method correctly calculates the percentages of teams getting their preferred choices.
*It handles special cases where the expected percentages are not a number (NaN).

<pre>
it 'correctly calculates percentages for teams getting their choices' do
controller.bidding_table_for_each_topic

# Assuming you have a way to know the expected percentages
expected_percentages = { 1 => Float::NAN,
2 => Float::NAN,
3 => Float::NAN }

percentages = controller.instance_variable_get(:@percentages)
expect(percentages[1].nan?).to be true if expected_percentages[1].nan?
expect(percentages[2].nan?).to be true if expected_percentages[2].nan?
expect(percentages[3].nan?).to be true if expected_percentages[3].nan?
end
</pre>

Rspec Testing <code> app/views/lottery/bidding_table_for_each_topic.html.erb </code>

== Relevant Links ==

'''Github Repository: ''' https://github.com/Shreshth-Malik/expertiza

'''Demo Video:''' https://www.youtube.com/watch?v=pGmHyqLj7PM

'''Pull Request:''' https://github.com/expertiza/expertiza/pull/2659

== Testing Credentials ==

username: instructor6

password: password

== Team ==
'''Mentor'''

Edward F. Gehringer (efg@ncsu.edu)

'''Members'''

Richard Li (rli14@ncsu.edu)

Shreshth Malik (smalik4@ncsu.edu)

Shuai Chen (schen76@ncsu.edu)

CSC/ECE 517 Fall 2023 - E2360. View for Results of Bidding (Phase2)

2023-12-14T20:36:33Z

Schen76: /* Code Effort */

== Motivation ==

The bidding view is needed because we don’t have a way of finding out whether the bidding algorithm is running correctly. This project is to add a bidding view to show how the topics are assigned to those teams who bid.

== Work Plan ==

Based on the project's objectives and feedback received from our mentor, we have identified specific areas for improvement:

1) Refactor variable names within methods such as "bidding_details" and variables like "Topic name" and "Bidding teams" to enhance clarity and specificity.

2) Adjust capitalization for certain components, ensuring that only the first word is capitalized for consistency.

3) Introduce calculations to determine percentages based on additional data, such as the total number of teams and the number of teams for each priority, within the "lottery_controller."

4) Conduct thorough testing of the modified controller and view to ensure optimal functionality.

[[File:Newfeature.jpg | 888px]]

To add functionality for showing the percentages of the number of teams that got their #1, #2, and #3 choices. We can follow these high-level steps:

'''Lottery_Controller:'''

i) Calculate the Total Number of Teams: Before we can calculate percentages, we need to know the total number of teams that participated in the bidding process. This will be our denominator in the percentage calculation.

ii) Calculate the Number of Teams for Each Priority: From our `bidding_details` method, we already have counts for how many teams bid on each topic as their #1, #2, and #3 choice (`@count1`, `@count2`, `@count3`). However, these counts are currently organized by topic. We would need to modify this to count how many teams got their #1, #2, and #3 choices as their assigned topic.

iii) Calculate Percentages: Once we have the number of teams that got their #1, #2, and #3 choices, we can calculate the percentages by dividing these numbers by the total number of teams and multiplying by 100.

'''Bidding_detail view:'''

i) Update the View and Display Percentages: Above the table in our previous view, we can add a section to display these percentages.

ii) Format the Display: We will use a bold heading for each percentage type and format the number to a fixed number of decimal places.

iii) Ensure Responsiveness: Make sure the display of these percentages adjusts well to different screen sizes, maintaining readability and layout consistency.

== Code Effort ==

Change in <code> app/controllers/lottery_controller.rb </code>

'''method 1: bidding_table_for_topics'''

This method generates a bidding table for each topic within an assignment. It performs several operations to gather and organize data related to topics, bids, and teams. Here's a breakdown of what the code does:

1. Fetch Assignment:

*It retrieves the assignment with the specified params[:id] from the database and stores it in the @assignment instance variable.

2. Fetch Topics:

*It retrieves all sign-up topics associated with the assignment and stores them in the @topics instance variable.

3. Fetch Bids and Assigned Teams:

For each topic in @topics, it:
*Retrieves all bids associated with that topic and stores them in a hash, where the key is the topic's ID and the value is an array of bids with their associated teams and priorities.
*Retrieves teams that are not waitlisted for the topic and stores them in a hash, again using the topic's ID as the key and an array of teams as the value.

4. Priority Count Calculation:

*It dynamically computes and updates the counts for each bid priority level (1, 2, and 3) for each topic. These counts are stored in instance variables named @count1, @count2, and @count3. These instance variables are hashes where the keys are topic IDs, and the values are counts for each priority level.

5. Computes Total Teams:

*It determines the total number of teams across all topics in the assignment by counting distinct team IDs among all non-waitlisted teams for the specified topics.

6. Computes Priority Counts and Percentages:

*It calls two helper methods, compute_priority_counts and compute_percentages, to compute the total counts of teams at each priority level and the corresponding percentages. The results are stored in the @priority_counts and @percentages instance variables, respectively.

<pre>
# Prepares data for displaying the bidding details for each topic within an assignment.
# It computes the number of bids for each priority (1, 2, 3) per topic and also computes
# the overall percentages of teams that received their first, second, and third choice.
def bidding_table_for_topics
@assignment = Assignment.find(params[:id])
# Fetch all topics for the assignment
@topics = @assignment.sign_up_topics
# Fetch all bids for these topics
@bids_by_topic = {}
@assigned_teams_by_topic = {} # This will store the assigned teams for each topic
@topics.each do |topic|
# Assuming bids are stored with a topic_id, and each bid has a team associated with it
@bids_by_topic[topic.id] = Bid.where(topic_id: topic.id).map { |bid| { team: bid.team, priority: bid.priority } }
# Fetch teams that are not waitlisted for this topic
@assigned_teams_by_topic[topic.id] = SignedUpTeam.where(topic_id: topic.id, is_waitlisted: false).map(&:team)
# Dynamically initializing and updating @count1, @count2, and @count3
(1..3).each do |priority|
instance_variable_set("@count#{priority}", Hash.new(0)) unless instance_variable_defined?("@count#{priority}")
instance_variable_get("@count#{priority}")[topic.id] = @bids_by_topic[topic.id].count { |bid| bid[:priority] == priority }
end
end
# Computes the total number of teams and percentages after fetching bid details
topic_ids = SignUpTopic.where(assignment_id: @assignment.id).pluck(:id)
@total_teams = SignedUpTeam.where(topic_id: topic_ids).distinct.count(:team_id)
@priority_counts = compute_priority_counts(@assigned_teams_by_topic, @bids_by_topic)
@percentages = compute_percentages(@priority_counts, @total_teams)

end
</pre>

'''method 2: compute_priority_counts'''

1. Parameters
*assigned_teams_by_topic (Hash): A hash mapping each topic to an array of assigned teams.
*bids_by_topic (Hash): A hash mapping each topic to an array of bid objects, where each bid object is a hash containing team and priority information.

2. Functionality
*Initial Setup: Initializes a hash priority_counts with keys 1, 2, and 3, each having an initial value of 0. These keys represent the priority levels, and their values count the number of teams assigned to each level.

*Iterating Over Topics and Teams: Iterates over each topic and its associated teams found in assigned_teams_by_topic. For each team in a topic, the method searches bids_by_topic[topic_id] to find a bid made by the team.

*Updating Priority Counts: If a bid is found, the method increments the count in priority_counts corresponding to the priority level in the bid. This process effectively tallies the number of teams assigned to each priority level.

3. Returns
*priority_counts (Hash): A hash with keys 1, 2, and 3, where each key's value represents the count of teams assigned to that respective priority level.

<pre>
# Computes the count of assigned teams for each priority level (1, 2, 3) across all topics.
# It checks each team associated with a topic and determines if the team's bid matches
# one of the priority levels, incrementing the respective count if so.
def compute_priority_counts(assigned_teams_by_topic, bids_by_topic)
priority_counts = { 1 => 0, 2 => 0, 3 => 0 }
assigned_teams_by_topic.each do |topic_id, teams|
teams.each do |team|
bid_info = bids_by_topic[topic_id].find { |bid| bid[:team] == team }
priority_counts[bid_info[:priority]] += 1 if bid_info
end
end
priority_counts
end
</pre>

'''method 3: compute_percentages'''

* This method computes the percentages of teams that received their first, second, and third choice based on the counts of teams at each priority level.

<pre>
# Computes the percentages of teams that received their first, second, and third choice
# based on the counts of teams at each priority level.
def compute_percentages(priority_counts, total_teams)
priority_counts.transform_values { |count| (count.to_f / total_teams * 100).round(2) }
end
</pre>

Change in <code> app/views/lottery/bidding_table_for_topics.html.erb </code>

[[File:bidding_percentage.png | 888px]]

Components:

1. Percentage Display Section

*This section is styled with a border, padding, and a background color to make it visually distinct.
*It contains a subtitle (h4) describing the content: "Percentage of Teams Getting Their Choices."
*A list (ul) displays the percentages of teams that received their 1st, 2nd, and 3rd choice. These percentages are pulled dynamically from @percentages array.
*The colors of the percentage values vary based on the choice priority (green for #1, orange for #2, and red for #3).
Custom CSS Styles

2. Bidding Details Table

*A table with headers for Topic ID, Topic Name, Bidding Teams, and bids.
*The table body (<tbody>) dynamically generates rows for each topic using a loop (<% @topics.each do |topic| %>).
*For each topic, the table displays its name, ID, bidding teams, and the number of bids for each choice.
*Teams are marked with the .assigned-team class if they are assigned to the topic.
*Bid counts are displayed, with a placeholder ("–") if the count is zero.

<pre>
<table class="table table-bordered table-hover">
<thead>
<tr>
<th>Topic id</th>
<th>Topic name</th>
<th>Bidding teams</th>
<th>#1 bids</th>
<th>#2 bids</th>
<th>#3 bids</th>
</tr>
</thead>
<tbody>
<% @topics.each do |topic| %>
<tr>
<td><%= topic.id %></td>
<td><%= topic.topic_name %></td>
<td class="teams-column">
<% @bids_by_topic[topic.id].each do |bid_info| %>
<% team = bid_info[:team] %>
<% assigned_team = @assigned_teams_by_topic[topic.id].include?(team) %>
<span class="<%= assigned_team ? 'assigned-team' : '' %>">
<%= team.name %> (#<%= bid_info[:priority] %>)
</span>
<% end %>
</td>
<td class="bids-column">
<% if @count1[topic.id] != 0%>
<%= @count1[topic.id] %>
<%else%>
–
<%end%>
</td>
<td class="bids-column">
<% if @count2[topic.id] != 0%>
<%= @count2[topic.id] %>
<%else%>
–
<%end%>
</td>
<td class="bids-column">
<% if @count3[topic.id] != 0%>
<%= @count3[topic.id] %>
<%else%>
–
<%end%>
</td>
</tr>
<% end %>
</tbody>
</table>

</pre>

== Testing ==

1. Test for Populating Bids and Assigned Teams:
*This test ensures that the bidding_table_for_each_topic method correctly populates bids and assigned teams for each topic.
*It checks if @bids_by_topic is populated correctly, verifying the length of bids for specific topics.
*It tests @assigned_teams_by_topic, ensuring it handles cases where topics have no teams.

<pre>

it 'populates bids and assigned teams for each topic, handling topics with no teams' do
controller.bidding_table_for_each_topic
# Check if @bids_by_topic is populated correctly
expect(controller.instance_variable_get(:@bids_by_topic)[topic1.id].length).to eq(1)
expect(controller.instance_variable_get(:@bids_by_topic)[topic2.id].length).to eq(1)
# Check if @assigned_teams_by_topic is populated correctly, allowing for no teams
assigned_teams_topic1 = controller.instance_variable_get(:@assigned_teams_by_topic)[topic1.id]
if assigned_teams_topic1
expect(assigned_teams_topic1.length).to(satisfy { |value| (value == 0) || (value == 1) })
else
expect(assigned_teams_topic1).to be_nil
end
# Check the counts of bids for each priority level
# Ensure to adjust these based on what is set up in your test data
expect(controller.instance_variable_get(:@count1)[topic1.id]).to eq(1)
# assuming there is one bid with priority 1 for topic1
expect(controller.instance_variable_get(:@count2)[topic1.id]).to eq(0)
# assuming there are no bids with priority 2 for topic1
expect(controller.instance_variable_get(:@count3)[topic1.id]).to eq(0)
# assuming there are no bids with priority 3 for topic1
end

</pre>

2. Test for Fetching All Topics:
*This test verifies that all topics for the assignment are fetched and stored in @topics.

<pre>
it 'fetches all topics for the assignment' do
controller.bidding_table_for_each_topic
expect(controller.instance_variable_get(:@topics)).to match_array([topic1, topic2, topic3, topic4])
end
</pre>

3. Test for Calculating Priority Counts:
*This test checks the calculation of priority counts for each topic.
*It compares the calculated priority counts against an expected set of values.
*It verifies the priority count is computing the values precisely for topics.

<pre>
it 'correctly calculates priority counts for each topic' do
controller.bidding_table_for_each_topic

# Assuming you have a way to know the expected counts for each priority
expected_priority_counts = { 1 => 0,
2 => 0,
3 => 0 }

priority_counts = controller.instance_variable_get(:@priority_counts)
expect(priority_counts).to eq(expected_priority_counts)
end
</pre>

4. Test for Calculating Percentages for Teams Getting Their Choices:
*This test ensures that the method correctly calculates the percentages of teams getting their preferred choices.
*It handles special cases where the expected percentages are not a number (NaN).

<pre>
it 'correctly calculates percentages for teams getting their choices' do
controller.bidding_table_for_each_topic

# Assuming you have a way to know the expected percentages
expected_percentages = { 1 => Float::NAN,
2 => Float::NAN,
3 => Float::NAN }

percentages = controller.instance_variable_get(:@percentages)
expect(percentages[1].nan?).to be true if expected_percentages[1].nan?
expect(percentages[2].nan?).to be true if expected_percentages[2].nan?
expect(percentages[3].nan?).to be true if expected_percentages[3].nan?
end
</pre>

Rspec Testing <code> app/views/lottery/bidding_table_for_each_topic.html.erb </code>

== Relevant Links ==

'''Github Repository: ''' https://github.com/Shreshth-Malik/expertiza

'''Demo Video:''' https://www.youtube.com/watch?v=pGmHyqLj7PM

'''Pull Request:''' https://github.com/expertiza/expertiza/pull/2659

== Testing Credentials ==

username: instructor6

password: password

== Team ==
'''Mentor'''

Edward F. Gehringer (efg@ncsu.edu)

'''Members'''

Richard Li (rli14@ncsu.edu)

Shreshth Malik (smalik4@ncsu.edu)

Shuai Chen (schen76@ncsu.edu)

CSC/ECE 517 Fall 2023 - E2360. View for Results of Bidding (Phase2)

2023-12-14T20:32:14Z

Schen76: /* Code Effort */

== Motivation ==

The bidding view is needed because we don’t have a way of finding out whether the bidding algorithm is running correctly. This project is to add a bidding view to show how the topics are assigned to those teams who bid.

== Work Plan ==

Based on the project's objectives and feedback received from our mentor, we have identified specific areas for improvement:

1) Refactor variable names within methods such as "bidding_details" and variables like "Topic name" and "Bidding teams" to enhance clarity and specificity.

2) Adjust capitalization for certain components, ensuring that only the first word is capitalized for consistency.

3) Introduce calculations to determine percentages based on additional data, such as the total number of teams and the number of teams for each priority, within the "lottery_controller."

4) Conduct thorough testing of the modified controller and view to ensure optimal functionality.

[[File:Newfeature.jpg | 888px]]

To add functionality for showing the percentages of the number of teams that got their #1, #2, and #3 choices. We can follow these high-level steps:

'''Lottery_Controller:'''

i) Calculate the Total Number of Teams: Before we can calculate percentages, we need to know the total number of teams that participated in the bidding process. This will be our denominator in the percentage calculation.

ii) Calculate the Number of Teams for Each Priority: From our `bidding_details` method, we already have counts for how many teams bid on each topic as their #1, #2, and #3 choice (`@count1`, `@count2`, `@count3`). However, these counts are currently organized by topic. We would need to modify this to count how many teams got their #1, #2, and #3 choices as their assigned topic.

iii) Calculate Percentages: Once we have the number of teams that got their #1, #2, and #3 choices, we can calculate the percentages by dividing these numbers by the total number of teams and multiplying by 100.

'''Bidding_detail view:'''

i) Update the View and Display Percentages: Above the table in our previous view, we can add a section to display these percentages.

ii) Format the Display: We will use a bold heading for each percentage type and format the number to a fixed number of decimal places.

iii) Ensure Responsiveness: Make sure the display of these percentages adjusts well to different screen sizes, maintaining readability and layout consistency.

== Code Effort ==

Change in <code> app/controllers/lottery_controller.rb </code>

'''method 1: bidding_table_for_topics'''

This method generates a bidding table for each topic within an assignment. It performs several operations to gather and organize data related to topics, bids, and teams. Here's a breakdown of what the code does:

1. Fetch Assignment:

*It retrieves the assignment with the specified params[:id] from the database and stores it in the @assignment instance variable.

2. Fetch Topics:

*It retrieves all sign-up topics associated with the assignment and stores them in the @topics instance variable.

3. Fetch Bids and Assigned Teams:

For each topic in @topics, it:
*Retrieves all bids associated with that topic and stores them in a hash, where the key is the topic's ID and the value is an array of bids with their associated teams and priorities.
*Retrieves teams that are not waitlisted for the topic and stores them in a hash, again using the topic's ID as the key and an array of teams as the value.

4. Priority Count Calculation:

*It dynamically computes and updates the counts for each bid priority level (1, 2, and 3) for each topic. These counts are stored in instance variables named @count1, @count2, and @count3. These instance variables are hashes where the keys are topic IDs, and the values are counts for each priority level.

5. Computes Total Teams:

*It determines the total number of teams across all topics in the assignment by counting distinct team IDs among all non-waitlisted teams for the specified topics.

6. Computes Priority Counts and Percentages:

*It calls two helper methods, compute_priority_counts and compute_percentages, to compute the total counts of teams at each priority level and the corresponding percentages. The results are stored in the @priority_counts and @percentages instance variables, respectively.

<pre>
# Prepares data for displaying the bidding details for each topic within an assignment.
# It computes the number of bids for each priority (1, 2, 3) per topic and also computes
# the overall percentages of teams that received their first, second, and third choice.
def bidding_table_for_topics
@assignment = Assignment.find(params[:id])
# Fetch all topics for the assignment
@topics = @assignment.sign_up_topics
# Fetch all bids for these topics
@bids_by_topic = {}
@assigned_teams_by_topic = {} # This will store the assigned teams for each topic
@topics.each do |topic|
# Assuming bids are stored with a topic_id, and each bid has a team associated with it
@bids_by_topic[topic.id] = Bid.where(topic_id: topic.id).map { |bid| { team: bid.team, priority: bid.priority } }
# Fetch teams that are not waitlisted for this topic
@assigned_teams_by_topic[topic.id] = SignedUpTeam.where(topic_id: topic.id, is_waitlisted: false).map(&:team)
# Dynamically initializing and updating @count1, @count2, and @count3
(1..3).each do |priority|
instance_variable_set("@count#{priority}", Hash.new(0)) unless instance_variable_defined?("@count#{priority}")
instance_variable_get("@count#{priority}")[topic.id] = @bids_by_topic[topic.id].count { |bid| bid[:priority] == priority }
end
end
# Computes the total number of teams and percentages after fetching bid details
topic_ids = SignUpTopic.where(assignment_id: @assignment.id).pluck(:id)
@total_teams = SignedUpTeam.where(topic_id: topic_ids).distinct.count(:team_id)
@priority_counts = compute_priority_counts(@assigned_teams_by_topic, @bids_by_topic)
@percentages = compute_percentages(@priority_counts, @total_teams)

end
</pre>

'''method 2: compute_priority_counts'''

1. Parameters
*assigned_teams_by_topic (Hash): A hash mapping each topic to an array of assigned teams.
*bids_by_topic (Hash): A hash mapping each topic to an array of bid objects, where each bid object is a hash containing team and priority information.

2. Functionality
*Initial Setup: Initializes a hash priority_counts with keys 1, 2, and 3, each having an initial value of 0. These keys represent the priority levels, and their values count the number of teams assigned to each level.

*Iterating Over Topics and Teams: Iterates over each topic and its associated teams found in assigned_teams_by_topic. For each team in a topic, the method searches bids_by_topic[topic_id] to find a bid made by the team.

*Updating Priority Counts: If a bid is found, the method increments the count in priority_counts corresponding to the priority level in the bid. This process effectively tallies the number of teams assigned to each priority level.

3. Returns
*priority_counts (Hash): A hash with keys 1, 2, and 3, where each key's value represents the count of teams assigned to that respective priority level.

<pre>
# Computes the count of assigned teams for each priority level (1, 2, 3) across all topics.
# It checks each team associated with a topic and determines if the team's bid matches
# one of the priority levels, incrementing the respective count if so.
def compute_priority_counts(assigned_teams_by_topic, bids_by_topic)
priority_counts = { 1 => 0, 2 => 0, 3 => 0 }
assigned_teams_by_topic.each do |topic_id, teams|
teams.each do |team|
bid_info = bids_by_topic[topic_id].find { |bid| bid[:team] == team }
priority_counts[bid_info[:priority]] += 1 if bid_info
end
end
priority_counts
end
</pre>

'''method 3: compute_percentages'''

* This method computes the percentages of teams that received their first, second, and third choice based on the counts of teams at each priority level.

<pre>
# Computes the percentages of teams that received their first, second, and third choice
# based on the counts of teams at each priority level.
def compute_percentages(priority_counts, total_teams)
priority_counts.transform_values { |count| (count.to_f / total_teams * 100).round(2) }
end
</pre>

Change in <code> app/views/lottery/bidding_table_for_each_topic.html.erb </code>

[[File:bidding_percentage.png | 888px]]

Components:

1. Percentage Display Section

*This section is styled with a border, padding, and a background color to make it visually distinct.
*It contains a subtitle (h4) describing the content: "Percentage of Teams Getting Their Choices."
*A list (ul) displays the percentages of teams that received their 1st, 2nd, and 3rd choice. These percentages are pulled dynamically from @percentages array.
*The colors of the percentage values vary based on the choice priority (green for #1, orange for #2, and red for #3).
Custom CSS Styles

2. Bidding Details Table

*A table with headers for Topic Name, Topic ID, Bidding Teams, and bids.
*The table body (<tbody>) dynamically generates rows for each topic using a loop (<% @topics.each do |topic| %>).
*For each topic, the table displays its name, ID, bidding teams, and the number of bids for each choice.
*Teams are marked with the .assigned-team class if they are assigned to the topic.
*Bid counts are displayed, with a placeholder ("–") if the count is zero.

<pre>
<table class="table table-bordered table-hover">
<thead>
<tr>
<th>Topic Name</th>
<th>Topic ID</th>
<th>Bidding Teams</th>
<th>#1 bids</th>
<th>#2 bids</th>
<th>#3 bids</th>
</tr>
</thead>
<tbody>
<% @topics.each do |topic| %>
<tr>
<td><%= topic.topic_name %></td>
<td><%= topic.id %></td>
<td>
<% @bids_by_topic[topic.id].each do |bid_info| %>
<% team = bid_info[:team] %>
<% assigned_team = @assigned_teams_by_topic[topic.id].include?(team) %>
<span class="<%= assigned_team ? 'assigned-team' : '' %>">
<%= team.name %> (#<%= bid_info[:priority] %>)
</span>
<% end %>
</td>
<td class="bids-column">
<% if @count1[topic.id] != 0%>
<%= @count1[topic.id] %>
<%else%>
–
<%end%>
</td>
<td class="bids-column">
<% if @count2[topic.id] != 0%>
<%= @count2[topic.id] %>
<%else%>
–
<%end%>
</td>
<td class="bids-column">
<% if @count3[topic.id] != 0%>
<%= @count3[topic.id] %>
<%else%>
–
<%end%>
</td>
</tr>
<% end %>
</tbody>
</table>

<a href="javascript:history.back()">Back</a>
</pre>

== Testing ==

1. Test for Populating Bids and Assigned Teams:
*This test ensures that the bidding_table_for_each_topic method correctly populates bids and assigned teams for each topic.
*It checks if @bids_by_topic is populated correctly, verifying the length of bids for specific topics.
*It tests @assigned_teams_by_topic, ensuring it handles cases where topics have no teams.

<pre>

it 'populates bids and assigned teams for each topic, handling topics with no teams' do
controller.bidding_table_for_each_topic
# Check if @bids_by_topic is populated correctly
expect(controller.instance_variable_get(:@bids_by_topic)[topic1.id].length).to eq(1)
expect(controller.instance_variable_get(:@bids_by_topic)[topic2.id].length).to eq(1)
# Check if @assigned_teams_by_topic is populated correctly, allowing for no teams
assigned_teams_topic1 = controller.instance_variable_get(:@assigned_teams_by_topic)[topic1.id]
if assigned_teams_topic1
expect(assigned_teams_topic1.length).to(satisfy { |value| (value == 0) || (value == 1) })
else
expect(assigned_teams_topic1).to be_nil
end
# Check the counts of bids for each priority level
# Ensure to adjust these based on what is set up in your test data
expect(controller.instance_variable_get(:@count1)[topic1.id]).to eq(1)
# assuming there is one bid with priority 1 for topic1
expect(controller.instance_variable_get(:@count2)[topic1.id]).to eq(0)
# assuming there are no bids with priority 2 for topic1
expect(controller.instance_variable_get(:@count3)[topic1.id]).to eq(0)
# assuming there are no bids with priority 3 for topic1
end

</pre>

2. Test for Fetching All Topics:
*This test verifies that all topics for the assignment are fetched and stored in @topics.

<pre>
it 'fetches all topics for the assignment' do
controller.bidding_table_for_each_topic
expect(controller.instance_variable_get(:@topics)).to match_array([topic1, topic2, topic3, topic4])
end
</pre>

3. Test for Calculating Priority Counts:
*This test checks the calculation of priority counts for each topic.
*It compares the calculated priority counts against an expected set of values.
*It verifies the priority count is computing the values precisely for topics.

<pre>
it 'correctly calculates priority counts for each topic' do
controller.bidding_table_for_each_topic

# Assuming you have a way to know the expected counts for each priority
expected_priority_counts = { 1 => 0,
2 => 0,
3 => 0 }

priority_counts = controller.instance_variable_get(:@priority_counts)
expect(priority_counts).to eq(expected_priority_counts)
end
</pre>

4. Test for Calculating Percentages for Teams Getting Their Choices:
*This test ensures that the method correctly calculates the percentages of teams getting their preferred choices.
*It handles special cases where the expected percentages are not a number (NaN).

<pre>
it 'correctly calculates percentages for teams getting their choices' do
controller.bidding_table_for_each_topic

# Assuming you have a way to know the expected percentages
expected_percentages = { 1 => Float::NAN,
2 => Float::NAN,
3 => Float::NAN }

percentages = controller.instance_variable_get(:@percentages)
expect(percentages[1].nan?).to be true if expected_percentages[1].nan?
expect(percentages[2].nan?).to be true if expected_percentages[2].nan?
expect(percentages[3].nan?).to be true if expected_percentages[3].nan?
end
</pre>

Rspec Testing <code> app/views/lottery/bidding_table_for_each_topic.html.erb </code>

== Relevant Links ==

'''Github Repository: ''' https://github.com/Shreshth-Malik/expertiza

'''Demo Video:''' https://www.youtube.com/watch?v=pGmHyqLj7PM

'''Pull Request:''' https://github.com/expertiza/expertiza/pull/2659

== Testing Credentials ==

username: instructor6

password: password

== Team ==
'''Mentor'''

Edward F. Gehringer (efg@ncsu.edu)

'''Members'''

Richard Li (rli14@ncsu.edu)

Shreshth Malik (smalik4@ncsu.edu)

Shuai Chen (schen76@ncsu.edu)

CSC/ECE 517 Fall 2023 - E2360. View for Results of Bidding (Phase2)

2023-12-14T20:22:56Z

Schen76: /* Code Effort */

== Motivation ==

The bidding view is needed because we don’t have a way of finding out whether the bidding algorithm is running correctly. This project is to add a bidding view to show how the topics are assigned to those teams who bid.

== Work Plan ==

Based on the project's objectives and feedback received from our mentor, we have identified specific areas for improvement:

1) Refactor variable names within methods such as "bidding_details" and variables like "Topic name" and "Bidding teams" to enhance clarity and specificity.

2) Adjust capitalization for certain components, ensuring that only the first word is capitalized for consistency.

3) Introduce calculations to determine percentages based on additional data, such as the total number of teams and the number of teams for each priority, within the "lottery_controller."

4) Conduct thorough testing of the modified controller and view to ensure optimal functionality.

[[File:Newfeature.jpg | 888px]]

To add functionality for showing the percentages of the number of teams that got their #1, #2, and #3 choices. We can follow these high-level steps:

'''Lottery_Controller:'''

i) Calculate the Total Number of Teams: Before we can calculate percentages, we need to know the total number of teams that participated in the bidding process. This will be our denominator in the percentage calculation.

ii) Calculate the Number of Teams for Each Priority: From our `bidding_details` method, we already have counts for how many teams bid on each topic as their #1, #2, and #3 choice (`@count1`, `@count2`, `@count3`). However, these counts are currently organized by topic. We would need to modify this to count how many teams got their #1, #2, and #3 choices as their assigned topic.

iii) Calculate Percentages: Once we have the number of teams that got their #1, #2, and #3 choices, we can calculate the percentages by dividing these numbers by the total number of teams and multiplying by 100.

'''Bidding_detail view:'''

i) Update the View and Display Percentages: Above the table in our previous view, we can add a section to display these percentages.

ii) Format the Display: We will use a bold heading for each percentage type and format the number to a fixed number of decimal places.

iii) Ensure Responsiveness: Make sure the display of these percentages adjusts well to different screen sizes, maintaining readability and layout consistency.

== Code Effort ==

Change in <code> app/controllers/lottery_controller.rb </code>

'''method 1: bidding_table_for_each_topic'''

This method generates a bidding table for each topic within an assignment. It performs several operations to gather and organize data related to topics, bids, and teams. Here's a breakdown of what the code does:

1. Fetch Assignment:

*It retrieves the assignment with the specified params[:id] from the database and stores it in the @assignment instance variable.

2. Fetch Topics:

*It retrieves all sign-up topics associated with the assignment and stores them in the @topics instance variable.

3. Fetch Bids and Assigned Teams:

For each topic in @topics, it:
*Retrieves all bids associated with that topic and stores them in a hash, where the key is the topic's ID and the value is an array of bids with their associated teams and priorities.
*Retrieves teams that are not waitlisted for the topic and stores them in a hash, again using the topic's ID as the key and an array of teams as the value.

4. Priority Count Calculation:

*It dynamically calculates and updates the counts for each bid priority level (1, 2, and 3) for each topic. These counts are stored in instance variables named @count1, @count2, and @count3. These instance variables are hashes where the keys are topic IDs, and the values are counts for each priority level.

5. Calculate Total Teams:

*It determines the total number of teams across all topics in the assignment by counting distinct team IDs among all non-waitlisted teams for the specified topics.

6. Calculate Priority Counts and Percentages:

*It calls two helper methods, calculate_priority_counts and calculate_percentages, to calculate the total counts of teams at each priority level and the corresponding percentages. The results are stored in the @priority_counts and @percentages instance variables, respectively.

<pre>
# Prepares data for displaying the bidding details for each topic within an assignment.
# It calculates the number of bids for each priority (1, 2, 3) per topic and also computes
# the overall percentages of teams that received their first, second, and third choice.
def bidding_table_for_each_topic
@assignment = Assignment.find(params[:id])
# Fetch all topics for the assignment
@topics = @assignment.sign_up_topics
# Fetch all bids for these topics
@bids_by_topic = {}
@assigned_teams_by_topic = {} # This will store the assigned teams for each topic
@topics.each do |topic|
# Assuming bids are stored with a topic_id, and each bid has a team associated with it
@bids_by_topic[topic.id] = Bid.where(topic_id: topic.id).map { |bid| { team: bid.team, priority: bid.priority } }
# Fetch teams that are not waitlisted for this topic
@assigned_teams_by_topic[topic.id] = SignedUpTeam.where(topic_id: topic.id, is_waitlisted: false).map(&:team)
# @count1[topic.id] += @bids_by_topic[topic.id].count { |bid| bid[:priority] == 1 }
# @count2[topic.id] += @bids_by_topic[topic.id].count { |bid| bid[:priority] == 2 }
# @count3[topic.id] += @bids_by_topic[topic.id].count { |bid| bid[:priority] == 3 }

# Dynamically initializing and updating @count1, @count2, and @count3
(1..3).each do |priority|
instance_variable_set("@count#{priority}", Hash.new(0)) unless instance_variable_defined?("@count#{priority}")
instance_variable_get("@count#{priority}")[topic.id] = @bids_by_topic[topic.id].count { |bid| bid[:priority] == priority }
end
end
# Calculate the total number of teams and percentages after fetching bid details
topic_ids = SignUpTopic.where(assignment_id: @assignment.id).pluck(:id)
@total_teams = SignedUpTeam.where(topic_id: topic_ids).distinct.count(:team_id)
@priority_counts = calculate_priority_counts(@assigned_teams_by_topic, @bids_by_topic)
@percentages = calculate_percentages(@priority_counts, @total_teams)

end
</pre>

'''method 2: calculate_priority_counts'''

1. Parameters
*assigned_teams_by_topic (Hash): A hash mapping each topic to an array of assigned teams.
*bids_by_topic (Hash): A hash mapping each topic to an array of bid objects, where each bid object is a hash containing team and priority information.

2. Functionality
*Initial Setup: Initializes a hash priority_counts with keys 1, 2, and 3, each having an initial value of 0. These keys represent the priority levels, and their values count the number of teams assigned to each level.

*Iterating Over Topics and Teams: Iterates over each topic and its associated teams found in assigned_teams_by_topic. For each team in a topic, the method searches bids_by_topic[topic_id] to find a bid made by the team.

*Updating Priority Counts: If a bid is found, the method increments the count in priority_counts corresponding to the priority level in the bid. This process effectively tallies the number of teams assigned to each priority level.

3. Returns
*priority_counts (Hash): A hash with keys 1, 2, and 3, where each key's value represents the count of teams assigned to that respective priority level.

<pre>
# Calculates the count of assigned teams for each priority level (1, 2, 3) across all topics.
# It checks each team associated with a topic and determines if the team's bid matches
# one of the priority levels, incrementing the respective count if so.
def calculate_priority_counts(assigned_teams_by_topic, bids_by_topic)
priority_counts = { 1 => 0, 2 => 0, 3 => 0 }
assigned_teams_by_topic.each do |topic_id, teams|
teams.each do |team|
bid_info = bids_by_topic[topic_id].find { |bid| bid[:team] == team }
priority_counts[bid_info[:priority]] += 1 if bid_info
end
end
priority_counts
end
</pre>

'''method 3: calculate_percentages'''

* This method calculates the percentages of teams that received their first, second, and third choice based on the counts of teams at each priority level.

<pre>
# Calculates the percentages of teams that received their first, second, and third choice
# based on the counts of teams at each priority level.
def calculate_percentages(priority_counts, total_teams)
priority_counts.transform_values { |count| (count.to_f / total_teams * 100).round(2) }
end
</pre>

Change in <code> app/views/lottery/bidding_table_for_each_topic.html.erb </code>

[[File:bidding_percentage.png | 888px]]

Components:

1. Percentage Display Section

*This section is styled with a border, padding, and a background color to make it visually distinct.
*It contains a subtitle (h4) describing the content: "Percentage of Teams Getting Their Choices."
*A list (ul) displays the percentages of teams that received their 1st, 2nd, and 3rd choice. These percentages are pulled dynamically from @percentages array.
*The colors of the percentage values vary based on the choice priority (green for #1, orange for #2, and red for #3).
Custom CSS Styles

2. Bidding Details Table

*A table with headers for Topic Name, Topic ID, Bidding Teams, and bids.
*The table body (<tbody>) dynamically generates rows for each topic using a loop (<% @topics.each do |topic| %>).
*For each topic, the table displays its name, ID, bidding teams, and the number of bids for each choice.
*Teams are marked with the .assigned-team class if they are assigned to the topic.
*Bid counts are displayed, with a placeholder ("–") if the count is zero.

<pre>
<table class="table table-bordered table-hover">
<thead>
<tr>
<th>Topic Name</th>
<th>Topic ID</th>
<th>Bidding Teams</th>
<th>#1 bids</th>
<th>#2 bids</th>
<th>#3 bids</th>
</tr>
</thead>
<tbody>
<% @topics.each do |topic| %>
<tr>
<td><%= topic.topic_name %></td>
<td><%= topic.id %></td>
<td>
<% @bids_by_topic[topic.id].each do |bid_info| %>
<% team = bid_info[:team] %>
<% assigned_team = @assigned_teams_by_topic[topic.id].include?(team) %>
<span class="<%= assigned_team ? 'assigned-team' : '' %>">
<%= team.name %> (#<%= bid_info[:priority] %>)
</span>
<% end %>
</td>
<td class="bids-column">
<% if @count1[topic.id] != 0%>
<%= @count1[topic.id] %>
<%else%>
–
<%end%>
</td>
<td class="bids-column">
<% if @count2[topic.id] != 0%>
<%= @count2[topic.id] %>
<%else%>
–
<%end%>
</td>
<td class="bids-column">
<% if @count3[topic.id] != 0%>
<%= @count3[topic.id] %>
<%else%>
–
<%end%>
</td>
</tr>
<% end %>
</tbody>
</table>

<a href="javascript:history.back()">Back</a>
</pre>

== Testing ==

1. Test for Populating Bids and Assigned Teams:
*This test ensures that the bidding_table_for_each_topic method correctly populates bids and assigned teams for each topic.
*It checks if @bids_by_topic is populated correctly, verifying the length of bids for specific topics.
*It tests @assigned_teams_by_topic, ensuring it handles cases where topics have no teams.

2. Test for Fetching All Topics:
*This test verifies that all topics for the assignment are fetched and stored in @topics.

3. Test for Calculating Priority Counts:
*This test checks the calculation of priority counts for each topic.
*It compares the calculated priority counts against an expected set of values.

4. Test for Calculating Percentages for Teams Getting Their Choices:
*This test ensures that the method correctly calculates the percentages of teams getting their preferred choices.
*It handles special cases where the expected percentages are not a number (NaN).

Rspec Testing <code> app/views/lottery/bidding_table_for_each_topic.html.erb </code>

<pre>
describe '#bidding_table_for_each_topic' do
before :each do
# Set the assignment id in the params
params = ActionController::Parameters.new(id: assignment.id)
allow(controller).to receive(:params).and_return(params)
end
it 'populates bids and assigned teams for each topic, handling topics with no teams' do
controller.bidding_table_for_each_topic
# Check if @bids_by_topic is populated correctly
expect(controller.instance_variable_get(:@bids_by_topic)[topic1.id].length).to eq(1)
expect(controller.instance_variable_get(:@bids_by_topic)[topic2.id].length).to eq(1)
# Check if @assigned_teams_by_topic is populated correctly, allowing for no teams
assigned_teams_topic1 = controller.instance_variable_get(:@assigned_teams_by_topic)[topic1.id]
if assigned_teams_topic1
expect(assigned_teams_topic1.length).to(satisfy { |value| (value == 0) || (value == 1) })
else
expect(assigned_teams_topic1).to be_nil
end
# Check the counts of bids for each priority level
# Ensure to adjust these based on what is set up in your test data
expect(controller.instance_variable_get(:@count1)[topic1.id]).to eq(1)
# assuming there is one bid with priority 1 for topic1
expect(controller.instance_variable_get(:@count2)[topic1.id]).to eq(0)
# assuming there are no bids with priority 2 for topic1
expect(controller.instance_variable_get(:@count3)[topic1.id]).to eq(0)
# assuming there are no bids with priority 3 for topic1
end

it 'fetches all topics for the assignment' do
controller.bidding_table_for_each_topic
expect(controller.instance_variable_get(:@topics)).to match_array([topic1, topic2, topic3, topic4])
end

it 'correctly calculates priority counts for each topic' do
controller.bidding_table_for_each_topic

# Assuming you have a way to know the expected counts for each priority
expected_priority_counts = { 1 => 0,
2 => 0,
3 => 0 }

priority_counts = controller.instance_variable_get(:@priority_counts)
expect(priority_counts).to eq(expected_priority_counts)
end

it 'correctly calculates percentages for teams getting their choices' do
controller.bidding_table_for_each_topic

# Assuming you have a way to know the expected percentages
expected_percentages = { 1 => Float::NAN,
2 => Float::NAN,
3 => Float::NAN }

percentages = controller.instance_variable_get(:@percentages)
expect(percentages[1].nan?).to be true if expected_percentages[1].nan?
expect(percentages[2].nan?).to be true if expected_percentages[2].nan?
expect(percentages[3].nan?).to be true if expected_percentages[3].nan?
end
end
end
</pre>

== Relevant Links ==

'''Github Repository: ''' https://github.com/Shreshth-Malik/expertiza

'''Demo Video:''' https://www.youtube.com/watch?v=pGmHyqLj7PM

== Testing Credentials ==

username: instructor6

password: password

== Team ==
'''Mentor'''

Edward F. Gehringer (efg@ncsu.edu)

'''Members'''

Richard Li (rli14@ncsu.edu)

Shreshth Malik (smalik4@ncsu.edu)

Shuai Chen (schen76@ncsu.edu)

CSC/ECE 517 Fall 2023 - E2360. View for Results of Bidding (Phase2)

2023-12-14T20:20:23Z

Schen76: /* Code Effort */

== Motivation ==

The bidding view is needed because we don’t have a way of finding out whether the bidding algorithm is running correctly. This project is to add a bidding view to show how the topics are assigned to those teams who bid.

== Work Plan ==

Based on the project's objectives and feedback received from our mentor, we have identified specific areas for improvement:

1) Refactor variable names within methods such as "bidding_details" and variables like "Topic name" and "Bidding teams" to enhance clarity and specificity.

2) Adjust capitalization for certain components, ensuring that only the first word is capitalized for consistency.

3) Introduce calculations to determine percentages based on additional data, such as the total number of teams and the number of teams for each priority, within the "lottery_controller."

4) Conduct thorough testing of the modified controller and view to ensure optimal functionality.

[[File:Newfeature.jpg | 888px]]

To add functionality for showing the percentages of the number of teams that got their #1, #2, and #3 choices. We can follow these high-level steps:

'''Lottery_Controller:'''

i) Calculate the Total Number of Teams: Before we can calculate percentages, we need to know the total number of teams that participated in the bidding process. This will be our denominator in the percentage calculation.

ii) Calculate the Number of Teams for Each Priority: From our `bidding_details` method, we already have counts for how many teams bid on each topic as their #1, #2, and #3 choice (`@count1`, `@count2`, `@count3`). However, these counts are currently organized by topic. We would need to modify this to count how many teams got their #1, #2, and #3 choices as their assigned topic.

iii) Calculate Percentages: Once we have the number of teams that got their #1, #2, and #3 choices, we can calculate the percentages by dividing these numbers by the total number of teams and multiplying by 100.

'''Bidding_detail view:'''

i) Update the View and Display Percentages: Above the table in our previous view, we can add a section to display these percentages.

ii) Format the Display: We will use a bold heading for each percentage type and format the number to a fixed number of decimal places.

iii) Ensure Responsiveness: Make sure the display of these percentages adjusts well to different screen sizes, maintaining readability and layout consistency.

== Code Effort ==

Change in <code> app/controllers/lottery_controller.rb </code>

'''method 1: bidding_table_for_each_topic'''

This method generates a bidding table for each topic within an assignment. It performs several operations to gather and organize data related to topics, bids, and teams. Here's a breakdown of what the code does:

1. Fetch Assignment:

*It retrieves the assignment with the specified params[:id] from the database and stores it in the @assignment instance variable.

2. Fetch Topics:

*It retrieves all sign-up topics associated with the assignment and stores them in the @topics instance variable.

3. Fetch Bids and Assigned Teams:

For each topic in @topics, it:
*Retrieves all bids associated with that topic and stores them in a hash, where the key is the topic's ID and the value is an array of bids with their associated teams and priorities.
*Retrieves teams that are not waitlisted for the topic and stores them in a hash, again using the topic's ID as the key and an array of teams as the value.

4. Priority Count Calculation:

*It dynamically calculates and updates the counts for each bid priority level (1, 2, and 3) for each topic. These counts are stored in instance variables named @count1, @count2, and @count3. These instance variables are hashes where the keys are topic IDs, and the values are counts for each priority level.

5. Calculate Total Teams:

*It determines the total number of teams across all topics in the assignment by counting distinct team IDs among all non-waitlisted teams for the specified topics.

6. Calculate Priority Counts and Percentages:

*It calls two helper methods, calculate_priority_counts and calculate_percentages, to calculate the total counts of teams at each priority level and the corresponding percentages. The results are stored in the @priority_counts and @percentages instance variables, respectively.

<pre>
# Prepares data for displaying the bidding details for each topic within an assignment.
# It calculates the number of bids for each priority (1, 2, 3) per topic and also computes
# the overall percentages of teams that received their first, second, and third choice.
def bidding_table_for_each_topic
@assignment = Assignment.find(params[:id])
# Fetch all topics for the assignment
@topics = @assignment.sign_up_topics
# Fetch all bids for these topics
@bids_by_topic = {}
@assigned_teams_by_topic = {} # This will store the assigned teams for each topic
@topics.each do |topic|
# Assuming bids are stored with a topic_id, and each bid has a team associated with it
@bids_by_topic[topic.id] = Bid.where(topic_id: topic.id).map { |bid| { team: bid.team, priority: bid.priority } }
# Fetch teams that are not waitlisted for this topic
@assigned_teams_by_topic[topic.id] = SignedUpTeam.where(topic_id: topic.id, is_waitlisted: false).map(&:team)
# @count1[topic.id] += @bids_by_topic[topic.id].count { |bid| bid[:priority] == 1 }
# @count2[topic.id] += @bids_by_topic[topic.id].count { |bid| bid[:priority] == 2 }
# @count3[topic.id] += @bids_by_topic[topic.id].count { |bid| bid[:priority] == 3 }

# Dynamically initializing and updating @count1, @count2, and @count3
(1..3).each do |priority|
instance_variable_set("@count#{priority}", Hash.new(0)) unless instance_variable_defined?("@count#{priority}")
instance_variable_get("@count#{priority}")[topic.id] = @bids_by_topic[topic.id].count { |bid| bid[:priority] == priority }
end
end
# Calculate the total number of teams and percentages after fetching bid details
topic_ids = SignUpTopic.where(assignment_id: @assignment.id).pluck(:id)
@total_teams = SignedUpTeam.where(topic_id: topic_ids).distinct.count(:team_id)
@priority_counts = calculate_priority_counts(@assigned_teams_by_topic, @bids_by_topic)
@percentages = calculate_percentages(@priority_counts, @total_teams)

end
</pre>

'''method 2: calculate_priority_counts'''

1. Parameters
*assigned_teams_by_topic (Hash): A hash mapping each topic to an array of assigned teams.
*bids_by_topic (Hash): A hash mapping each topic to an array of bid objects, where each bid object is a hash containing team and priority information.

2. Functionality
*Initial Setup: Initializes a hash priority_counts with keys 1, 2, and 3, each having an initial value of 0. These keys represent the priority levels, and their values count the number of teams assigned to each level.

*Iterating Over Topics and Teams: Iterates over each topic and its associated teams found in assigned_teams_by_topic. For each team in a topic, the method searches bids_by_topic[topic_id] to find a bid made by the team.

*Updating Priority Counts: If a bid is found, the method increments the count in priority_counts corresponding to the priority level in the bid. This process effectively tallies the number of teams assigned to each priority level.

3. Returns
*priority_counts (Hash): A hash with keys 1, 2, and 3, where each key's value represents the count of teams assigned to that respective priority level.

<pre>
# Calculates the count of assigned teams for each priority level (1, 2, 3) across all topics.
# It checks each team associated with a topic and determines if the team's bid matches
# one of the priority levels, incrementing the respective count if so.
def calculate_priority_counts(assigned_teams_by_topic, bids_by_topic)
priority_counts = { 1 => 0, 2 => 0, 3 => 0 }
assigned_teams_by_topic.each do |topic_id, teams|
teams.each do |team|
bid_info = bids_by_topic[topic_id].find { |bid| bid[:team] == team }
priority_counts[bid_info[:priority]] += 1 if bid_info
end
end
priority_counts
end
</pre>

'''method 3: calculate_percentages'''

* This method calculates the percentages of teams that received their first, second, and third choice based on the counts of teams at each priority level.

<pre>
# Calculates the percentages of teams that received their first, second, and third choice
# based on the counts of teams at each priority level.
def calculate_percentages(priority_counts, total_teams)
priority_counts.transform_values { |count| (count.to_f / total_teams * 100).round(2) }
end
</pre>

Change in <code> app/views/lottery/bidding_table_for_each_topic.html.erb </code>

[[File:bidding_percentage.png | 888px]]

Components:

1. Percentage Display Section

*This section is styled with a border, padding, and a background color to make it visually distinct.
*It contains a subtitle (h4) describing the content: "Percentage of Teams Getting Their Choices."
*A list (ul) displays the percentages of teams that received their 1st, 2nd, and 3rd choice. These percentages are pulled dynamically from @percentages array.
*The colors of the percentage values vary based on the choice priority (green for #1, orange for #2, and red for #3).
Custom CSS Styles

2. Bidding Details Table

*A table with headers for Topic Name, Topic ID, Bidding Teams, and bids.
*The table body (<tbody>) dynamically generates rows for each topic using a loop (<% @topics.each do |topic| %>).
*For each topic, the table displays its name, ID, bidding teams, and the number of bids for each choice.
*Teams are marked with the .assigned-team class if they are assigned to the topic.
*Bid counts are displayed, with a placeholder ("–") if the count is zero.

<table class="table table-bordered table-hover">
<thead>
<tr>
<th>Topic Name</th>
<th>Topic ID</th>
<th>Bidding Teams</th>
<th>#1 bids</th>
<th>#2 bids</th>
<th>#3 bids</th>
</tr>
</thead>
<tbody>
<% @topics.each do |topic| %>
<tr>
<td><%= topic.topic_name %></td>
<td><%= topic.id %></td>
<td>
<% @bids_by_topic[topic.id].each do |bid_info| %>
<% team = bid_info[:team] %>
<% assigned_team = @assigned_teams_by_topic[topic.id].include?(team) %>
<span class="<%= assigned_team ? 'assigned-team' : '' %>">
<%= team.name %> (#<%= bid_info[:priority] %>)
</span>
<% end %>
</td>
<td class="bids-column">
<% if @count1[topic.id] != 0%>
<%= @count1[topic.id] %>
<%else%>
–
<%end%>
</td>
<td class="bids-column">
<% if @count2[topic.id] != 0%>
<%= @count2[topic.id] %>
<%else%>
–
<%end%>
</td>
<td class="bids-column">
<% if @count3[topic.id] != 0%>
<%= @count3[topic.id] %>
<%else%>
–
<%end%>
</td>
</tr>
<% end %>
</tbody>
</table>

<a href="javascript:history.back()">Back</a>
</pre>

== Testing ==

1. Test for Populating Bids and Assigned Teams:
*This test ensures that the bidding_table_for_each_topic method correctly populates bids and assigned teams for each topic.
*It checks if @bids_by_topic is populated correctly, verifying the length of bids for specific topics.
*It tests @assigned_teams_by_topic, ensuring it handles cases where topics have no teams.

2. Test for Fetching All Topics:
*This test verifies that all topics for the assignment are fetched and stored in @topics.

3. Test for Calculating Priority Counts:
*This test checks the calculation of priority counts for each topic.
*It compares the calculated priority counts against an expected set of values.

4. Test for Calculating Percentages for Teams Getting Their Choices:
*This test ensures that the method correctly calculates the percentages of teams getting their preferred choices.
*It handles special cases where the expected percentages are not a number (NaN).

Rspec Testing <code> app/views/lottery/bidding_table_for_each_topic.html.erb </code>

<pre>
describe '#bidding_table_for_each_topic' do
before :each do
# Set the assignment id in the params
params = ActionController::Parameters.new(id: assignment.id)
allow(controller).to receive(:params).and_return(params)
end
it 'populates bids and assigned teams for each topic, handling topics with no teams' do
controller.bidding_table_for_each_topic
# Check if @bids_by_topic is populated correctly
expect(controller.instance_variable_get(:@bids_by_topic)[topic1.id].length).to eq(1)
expect(controller.instance_variable_get(:@bids_by_topic)[topic2.id].length).to eq(1)
# Check if @assigned_teams_by_topic is populated correctly, allowing for no teams
assigned_teams_topic1 = controller.instance_variable_get(:@assigned_teams_by_topic)[topic1.id]
if assigned_teams_topic1
expect(assigned_teams_topic1.length).to(satisfy { |value| (value == 0) || (value == 1) })
else
expect(assigned_teams_topic1).to be_nil
end
# Check the counts of bids for each priority level
# Ensure to adjust these based on what is set up in your test data
expect(controller.instance_variable_get(:@count1)[topic1.id]).to eq(1)
# assuming there is one bid with priority 1 for topic1
expect(controller.instance_variable_get(:@count2)[topic1.id]).to eq(0)
# assuming there are no bids with priority 2 for topic1
expect(controller.instance_variable_get(:@count3)[topic1.id]).to eq(0)
# assuming there are no bids with priority 3 for topic1
end

it 'fetches all topics for the assignment' do
controller.bidding_table_for_each_topic
expect(controller.instance_variable_get(:@topics)).to match_array([topic1, topic2, topic3, topic4])
end

it 'correctly calculates priority counts for each topic' do
controller.bidding_table_for_each_topic

# Assuming you have a way to know the expected counts for each priority
expected_priority_counts = { 1 => 0,
2 => 0,
3 => 0 }

priority_counts = controller.instance_variable_get(:@priority_counts)
expect(priority_counts).to eq(expected_priority_counts)
end

it 'correctly calculates percentages for teams getting their choices' do
controller.bidding_table_for_each_topic

# Assuming you have a way to know the expected percentages
expected_percentages = { 1 => Float::NAN,
2 => Float::NAN,
3 => Float::NAN }

percentages = controller.instance_variable_get(:@percentages)
expect(percentages[1].nan?).to be true if expected_percentages[1].nan?
expect(percentages[2].nan?).to be true if expected_percentages[2].nan?
expect(percentages[3].nan?).to be true if expected_percentages[3].nan?
end
end
end
</pre>

== Relevant Links ==

'''Github Repository: ''' https://github.com/Shreshth-Malik/expertiza

'''Demo Video:''' https://www.youtube.com/watch?v=pGmHyqLj7PM

== Testing Credentials ==

username: instructor6

password: password

== Team ==
'''Mentor'''

Edward F. Gehringer (efg@ncsu.edu)

'''Members'''

Richard Li (rli14@ncsu.edu)

Shreshth Malik (smalik4@ncsu.edu)

Shuai Chen (schen76@ncsu.edu)

CSC/ECE 517 Fall 2023 - E2360. View for Results of Bidding

2023-12-06T05:34:26Z

Schen76:

== Expertiza ==

[http://expertiza.ncsu.edu/ Expertiza] is an open source project based on [http://rubyonrails.org/ Ruby on Rails] framework. Expertiza allows the instructor to create new assignments and customize new or existing assignments. It also allows the instructor to create a list of topics the students can sign up for. Students can form teams in Expertiza to work on various projects and assignments. Students can also peer review other students' submissions. Expertiza supports submission across various document types, including URLs and wiki pages.

== Background ==

When topics are opened up for bidding, students can see how “hot” each topic is by the color it has on their topic list. However, instructors have no way to view the bidding process except by impersonating students. Furthermore, when the bidding assignment algorithm is run, there is no way to verify that it did in fact assign teams to topics they had chosen.

== Previous Work ==

[[CSC/ECE_517_Spring_2022_-_E2245:_View_for_results_of_bidding]]

== Accomplishments ==

This project added a "View Bidding Details" when the instructor enables the "bidding for topics" feature. By clicking it, it redirects us to a new page, where shows the following details of bidding:

*Topic Name
*Bidding Teams
*Bidding Order
*The number of bidding a topic gets

Also, for each topic, the team that wins the bidding will be highlighted with a yellow background color so that the instructor can easily find out which team each topic is assigned to.

The button leads to a page that contains bidding information for the assignment. It displays the number of #1, #2, and #3 bids on a specific topic, the teams that bid and priority of their bid, and the name of the team that got assigned the topic is highlighted.

[[File:Bidding_button.png ‎| 888px]]

[[File:Bidding_details.png ‎| 888px]]

'''Files Involved:'''

The files to be worked upon are:

*./app/controllers/lottering_controller.rb
*./app/views/lottery/bidding_details.ntml.erb
*./app/assignments/edit/_topics.html.erb
*./spec/controllers/lottery_controller.rb

'''Team Members'''

*Richard Li rli14@ncsu.edu
*Shreshth Malik smalik4@ncsu.edu
*Shuai Chen schen76@ncsu.edu

== Implemented Code ==

'''1. Lottery Controller'''

File: <code>./app/controllers/lottery_controller.rb</code>

Method: <code>"bidding_details"</code>

Functionality:

(1) Assignment Retrieval:

*Retrieves the assignment based on the provided id from the params.

(2) Topic Fetching:

*Gathers all the sign-up topics associated with the retrieved assignment.

(3) Initialization of Data Structures:

*Initializes two hash data structures:
#@bids_by_topic: To store bids by topic.
#@assigned_teams_by_topic: To store teams assigned to each topic.

(4) Data Aggregation:

Iterates through each topic and performs the following actions:

(i) Bids Gathering:
*Fetches all bids for each topic.
*Bids are stored in @bids_by_topic, mapped by the topic.id. Each bid includes the team and its priority.

(ii) Assigned Teams Gathering:
*Retrieves teams that are assigned to a topic and are not waitlisted.
*The results are stored in @assigned_teams_by_topic, indexed by topic.id.

(5) Priority Counts:

*For each topic, the method calculates the number of bids at each priority level (1 to 3).
*It dynamically initializes and updates three instance variables: @count1, @count2, and @count3.
*Each of these variables is a hash that maps topic IDs to the count of bids at the respective priority.

<pre>
def bidding_details
@assignment = Assignment.find(params[:id])
# Fetch all topics for the assignment
@topics = @assignment.sign_up_topics
# Fetch all bids for these topics
@bids_by_topic = {}
@assigned_teams_by_topic = {} # This will store the assigned teams for each topic
@topics.each do |topic|
# Assuming bids are stored with a topic_id, and each bid has a team associated with it
@bids_by_topic[topic.id] = Bid.where(topic_id: topic.id).map { |bid| { team: bid.team, priority: bid.priority } }
# Fetch teams that are not waitlisted for this topic
@assigned_teams_by_topic[topic.id] = SignedUpTeam.where(topic_id: topic.id, is_waitlisted: false).map(&:team)
# Dynamically initializing and updating @count1, @count2, and @count3
(1..3).each do |priority|
instance_variable_set("@count#{priority}", Hash.new(0)) unless instance_variable_defined?("@count#{priority}")
instance_variable_get("@count#{priority}")[topic.id] = @bids_by_topic[topic.id].count { |bid| bid[:priority] == priority }
end
end
end
</pre>

[[File:Bidding_details_controller.png | 888px]]

'''2. Bidding Details View'''

File: <code>./app/views/lottery/bidding_details.html.erb</code>

'''Added a button and corresponding JavaScript which toggles its visibility based on “Enable bidding for topics?” checkbox.'''

Components:

1. Custom CSS Style:

*A style block is defined to style elements with the assigned-team class. Teams assigned to a topic will have a yellow background and black text.

2. Bidding Details Table:

*A table is created with classes table, table-bordered, and table-hover for styling.
*The header (<thead>) section of the table defines five columns: "Topic Name", "Bidding Teams", and three columns for bid counts ("#1 bids", "#2 bids", "#3 bids").

3. Dynamic Table Rows:

*The <tbody> section uses ERB to iterate over each topic in the @topics array.
*Each topic creates a table row (<tr>) with the following data:
**Topic Name: Displayed using <%= topic.topic_name %>.
**Bidding Teams: A list of teams bidding on the topic. For each bid associated with the topic:
***The team's name and priority number are displayed.
***If the team is assigned to the topic, it is styled with the assigned-team class.
**Bid Counts: Three columns display the number of #1, #2, and #3 bids for each topic. If there are no bids, it displays "No bids yet".

4. Navigation Link:

<code><a href="javascript:history.back()">Back</a></code>: Provides a link to go back to the previous page in the browser history.

<pre>
<h3>Bidding Details for <%= @assignment.name %></h3>

<style>
.assigned-team {
background-color: yellow;
color: black;
}
</style>

<table class="table table-bordered table-hover">
<thead>
<tr>
<th>Topic Name</th>
<th>Bidding Teams</th>
<th>#1 bids</th>
<th>#2 bids</th>
<th>#3 bids</th>
</tr>
</thead>
<tbody>
<% @topics.each do |topic| %>
<tr>
<td><%= topic.topic_name %></td>
<td>
<% @bids_by_topic[topic.id].each do |bid_info| %>
<% team = bid_info[:team] %>
<% assigned_team = @assigned_teams_by_topic[topic.id].include?(team) %>
<span class="<%= assigned_team ? 'assigned-team' : '' %>">
<%= team.name %> (#<%= bid_info[:priority] %>)
</span>
<% end %>
</td>
<td>
<% if @count1[topic.id] != 0%>
<%= @count1[topic.id] %>
<%else%>
No bids yet
<%end%>
</td>
<td>
<% if @count2[topic.id] != 0%>
<%= @count2[topic.id] %>
<%else%>
No bids yet
<%end%>
</td>
<td>
<% if @count3[topic.id] != 0%>
<%= @count3[topic.id] %>
<%else%>
No bids yet
<%end%>
</td>
</tr>
<% end %>
</tbody>
</table>

<a href="javascript:history.back()">Back</a>
</pre>

[[File:Bidding_details_view.png | 888px]]

'''3. The button of View Bidding Details'''

File: <code>./app/assignments/edit/_topics.html.erb</code>

<pre>
<%= button_to 'View Bidding Details', {:controller => 'lottery', :action => 'bidding_details', :id => @assignment_form.assignment.id},
:method => :get, class: 'custom-button', id: 'bidding-button' %>
</pre>

[[File:View_bidding_button.png | 888px]]

'''4. RSpec Testing on "bidding_details" Method'''

File: <code>./spec/controllers/lottery_controller_spec.rb</code>

Structure:

1. Setup (before :each block):

*Initializes a testing environment before each test case.
*Sets up parameters (like assignment.id) to mimic a real request context.

2. Test Case 1: Populating Bids and Assigned Teams

*Objective: To test if the #bidding_details method correctly populates bids and assigned teams for each topic, including handling topics with no teams.
*Execution: Calls the #bidding_details method.
*Expectations:
**@bids_by_topic should correctly map topics to their respective bids.
**@assigned_teams_by_topic should correctly map topics to their assigned teams, handling cases where no teams are assigned.
**Counts of bids for each priority level (@count1, @count2, @count3) are checked against expected values.

3. Test Case 2: Fetching All Topics

*Objective: To verify if the method fetches all topics related to the assignment.
*Execution: Invokes #bidding_details.
*Expectation: The @topics instance variable should contain an array of all topics (e.g., [topic1, topic2, topic3, topic4]).

<pre>
describe '#bidding_details' do
before :each do
# Set the assignment id in the params
params = ActionController::Parameters.new(id: assignment.id)
allow(controller).to receive(:params).and_return(params)
end
it 'populates bids and assigned teams for each topic, handling topics with no teams' do
controller.bidding_details
# Check if @bids_by_topic is populated correctly
expect(controller.instance_variable_get(:@bids_by_topic)[topic1.id].length).to eq(1)
expect(controller.instance_variable_get(:@bids_by_topic)[topic2.id].length).to eq(1)
# Check if @assigned_teams_by_topic is populated correctly, allowing for no teams
assigned_teams_topic1 = controller.instance_variable_get(:@assigned_teams_by_topic)[topic1.id]
if assigned_teams_topic1
expect(assigned_teams_topic1.length).to(satisfy { |value| (value == 0) || (value == 1) })
else
expect(assigned_teams_topic1).to be_nil
end
# Check the counts of bids for each priority level
# Ensure to adjust these based on what is set up in your test data
expect(controller.instance_variable_get(:@count1)[topic1.id]).to eq(1) # assuming there is one bid with priority 1 for topic1
expect(controller.instance_variable_get(:@count2)[topic1.id]).to eq(0) # assuming there are no bids with priority 2 for topic1
expect(controller.instance_variable_get(:@count3)[topic1.id]).to eq(0) # assuming there are no bids with priority 3 for topic1
end

it 'fetches all topics for the assignment' do
controller.bidding_details
expect(controller.instance_variable_get(:@topics)).to match_array([topic1, topic2, topic3, topic4])
end
end
</pre>

[[File:Rspec_testing.png | 888px]]

== Relevant Links ==

'''Github Repository: ''' https://github.com/Shreshth-Malik/expertiza

== Testing Credentials ==

username: instructor6

password: password

== Team ==
'''Mentor'''

Edward F. Gehringer (efg@ncsu.edu)

'''Members'''

Richard Li (rli14@ncsu.edu)

Shreshth Malik (smalik4@ncsu.edu)

Shuai Chen (schen76@ncsu.edu)

CSC/ECE 517 Fall 2023 - E2360. View for Results of Bidding

2023-12-06T05:33:19Z

Schen76: /* Implemented Code */

CSC/ECE 517 Fall 2023 - E2360. View for Results of Bidding

2023-12-06T05:30:19Z

Schen76: /* Implemented Code */

== Expertiza ==

[http://expertiza.ncsu.edu/ Expertiza] is an open source project based on [http://rubyonrails.org/ Ruby on Rails] framework. Expertiza allows the instructor to create new assignments and customize new or existing assignments. It also allows the instructor to create a list of topics the students can sign up for. Students can form teams in Expertiza to work on various projects and assignments. Students can also peer review other students' submissions. Expertiza supports submission across various document types, including URLs and wiki pages.

== Background ==

When topics are opened up for bidding, students can see how “hot” each topic is by the color it has on their topic list. However, instructors have no way to view the bidding process except by impersonating students. Furthermore, when the bidding assignment algorithm is run, there is no way to verify that it did in fact assign teams to topics they had chosen.

== Previous Work ==

[[CSC/ECE_517_Spring_2022_-_E2245:_View_for_results_of_bidding]]

== Accomplishments ==

This project added a "View Bidding Details" when the instructor enables the "bidding for topics" feature. By clicking it, it redirects us to a new page, where shows the following details of bidding:

*Topic Name
*Bidding Teams
*Bidding Order
*The number of bidding a topic gets

Also, for each topic, the team that wins the bidding will be highlighted with a yellow background color so that the instructor can easily find out which team each topic is assigned to.

The button leads to a page that contains bidding information for the assignment. It displays the number of #1, #2, and #3 bids on a specific topic, the teams that bid and priority of their bid, and the name of the team that got assigned the topic is highlighted.

[[File:Bidding_button.png ‎| 888px]]

[[File:Bidding_details.png ‎| 888px]]

'''Files Involved:'''

The files to be worked upon are:

*./app/controllers/lottering_controller.rb
*./app/views/lottery/bidding_details.ntml.erb
*./app/assignments/edit/_topics.html.erb
*./spec/controllers/lottery_controller.rb

'''Team Members'''

*Richard Li rli14@ncsu.edu
*Shreshth Malik smalik4@ncsu.edu
*Shuai Chen schen76@ncsu.edu

== Implemented Code ==

'''1. Lottery Controller'''

File: <code>./app/controllers/lottery_controller.rb</code>

Method: <code>"bidding_details"</code>

Functionality:

(1) Assignment Retrieval:

*Retrieves the assignment based on the provided id from the params.

(2) Topic Fetching:

*Gathers all the sign-up topics associated with the retrieved assignment.

(3) Initialization of Data Structures:

*Initializes two hash data structures:
#@bids_by_topic: To store bids by topic.
#@assigned_teams_by_topic: To store teams assigned to each topic.

(4) Data Aggregation:

Iterates through each topic and performs the following actions:

(i) Bids Gathering:
*Fetches all bids for each topic.
*Bids are stored in @bids_by_topic, mapped by the topic.id. Each bid includes the team and its priority.

(ii) Assigned Teams Gathering:
*Retrieves teams that are assigned to a topic and are not waitlisted.
*The results are stored in @assigned_teams_by_topic, indexed by topic.id.

(5) Priority Counts:

*For each topic, the method calculates the number of bids at each priority level (1 to 3).
*It dynamically initializes and updates three instance variables: @count1, @count2, and @count3.
*Each of these variables is a hash that maps topic IDs to the count of bids at the respective priority.

<pre>
def bidding_details
@assignment = Assignment.find(params[:id])
# Fetch all topics for the assignment
@topics = @assignment.sign_up_topics
# Fetch all bids for these topics
@bids_by_topic = {}
@assigned_teams_by_topic = {} # This will store the assigned teams for each topic
@topics.each do |topic|
# Assuming bids are stored with a topic_id, and each bid has a team associated with it
@bids_by_topic[topic.id] = Bid.where(topic_id: topic.id).map { |bid| { team: bid.team, priority: bid.priority } }
# Fetch teams that are not waitlisted for this topic
@assigned_teams_by_topic[topic.id] = SignedUpTeam.where(topic_id: topic.id, is_waitlisted: false).map(&:team)
# Dynamically initializing and updating @count1, @count2, and @count3
(1..3).each do |priority|
instance_variable_set("@count#{priority}", Hash.new(0)) unless instance_variable_defined?("@count#{priority}")
instance_variable_get("@count#{priority}")[topic.id] = @bids_by_topic[topic.id].count { |bid| bid[:priority] == priority }
end
end
end
</pre>

[[File:Bidding_details_controller.png | 888px]]

'''2. Bidding Details View'''

File: <code>./app/views/lottery/bidding_details.html.erb</code>

'''Added a button and corresponding JavaScript which toggles its visibility based on “Enable bidding for topics?” checkbox.'''

Components:

1. Custom CSS Style:

*A style block is defined to style elements with the assigned-team class. Teams assigned to a topic will have a yellow background and black text.

2. Bidding Details Table:

*A table is created with classes table, table-bordered, and table-hover for styling.
*The header (<thead>) section of the table defines five columns: "Topic Name", "Bidding Teams", and three columns for bid counts ("#1 bids", "#2 bids", "#3 bids").

3. Dynamic Table Rows:

*The <tbody> section uses ERB to iterate over each topic in the @topics array.
*Each topic creates a table row (<tr>) with the following data:
**Topic Name: Displayed using <%= topic.topic_name %>.
**Bidding Teams: A list of teams bidding on the topic. For each bid associated with the topic:
***The team's name and priority number are displayed.
***If the team is assigned to the topic, it is styled with the assigned-team class.
**Bid Counts: Three columns display the number of #1, #2, and #3 bids for each topic. If there are no bids, it displays "No bids yet".

4. Navigation Link:

<code><a href="javascript:history.back()">Back</a></code>: Provides a link to go back to the previous page in the browser history.

<pre>
<h3>Bidding Details for <%= @assignment.name %></h3>

<style>
.assigned-team {
background-color: yellow;
color: black;
}
</style>

<table class="table table-bordered table-hover">
<thead>
<tr>
<th>Topic Name</th>
<th>Bidding Teams</th>
<th>#1 bids</th>
<th>#2 bids</th>
<th>#3 bids</th>
</tr>
</thead>
<tbody>
<% @topics.each do |topic| %>
<tr>
<td><%= topic.topic_name %></td>
<td>
<% @bids_by_topic[topic.id].each do |bid_info| %>
<% team = bid_info[:team] %>
<% assigned_team = @assigned_teams_by_topic[topic.id].include?(team) %>
<span class="<%= assigned_team ? 'assigned-team' : '' %>">
<%= team.name %> (#<%= bid_info[:priority] %>)
</span>
<% end %>
</td>
<td>
<% if @count1[topic.id] != 0%>
<%= @count1[topic.id] %>
<%else%>
No bids yet
<%end%>
</td>
<td>
<% if @count2[topic.id] != 0%>
<%= @count2[topic.id] %>
<%else%>
No bids yet
<%end%>
</td>
<td>
<% if @count3[topic.id] != 0%>
<%= @count3[topic.id] %>
<%else%>
No bids yet
<%end%>
</td>
</tr>
<% end %>
</tbody>
</table>

<a href="javascript:history.back()">Back</a>
</pre>

[[File:Bidding_details_view.png | 888px]]

'''3. The button of View Bidding Details'''

File: <code>./app/assignments/edit/_topics.html.erb</code>

<pre>
<%= button_to 'View Bidding Details', {:controller => 'lottery', :action => 'bidding_details', :id => @assignment_form.assignment.id},
:method => :get, class: 'custom-button', id: 'bidding-button' %>
</pre>

[[File:View_bidding_button.png | 888px]]

'''4. RSpec Testing on "bidding_details" Method'''

File: <code>./spec/controllers/lottery_controller_spec.rb</code>

<pre>
describe '#bidding_details' do
before :each do
# Set the assignment id in the params
params = ActionController::Parameters.new(id: assignment.id)
allow(controller).to receive(:params).and_return(params)
end
it 'populates bids and assigned teams for each topic, handling topics with no teams' do
controller.bidding_details
# Check if @bids_by_topic is populated correctly
expect(controller.instance_variable_get(:@bids_by_topic)[topic1.id].length).to eq(1)
expect(controller.instance_variable_get(:@bids_by_topic)[topic2.id].length).to eq(1)
# Check if @assigned_teams_by_topic is populated correctly, allowing for no teams
assigned_teams_topic1 = controller.instance_variable_get(:@assigned_teams_by_topic)[topic1.id]
if assigned_teams_topic1
expect(assigned_teams_topic1.length).to(satisfy { |value| (value == 0) || (value == 1) })
else
expect(assigned_teams_topic1).to be_nil
end
# Check the counts of bids for each priority level
# Ensure to adjust these based on what is set up in your test data
expect(controller.instance_variable_get(:@count1)[topic1.id]).to eq(1) # assuming there is one bid with priority 1 for topic1
expect(controller.instance_variable_get(:@count2)[topic1.id]).to eq(0) # assuming there are no bids with priority 2 for topic1
expect(controller.instance_variable_get(:@count3)[topic1.id]).to eq(0) # assuming there are no bids with priority 3 for topic1
end

it 'fetches all topics for the assignment' do
controller.bidding_details
expect(controller.instance_variable_get(:@topics)).to match_array([topic1, topic2, topic3, topic4])
end
end
</pre>

[[File:Rspec_testing.png | 888px]]

CSC/ECE 517 Fall 2023 - E2360. View for Results of Bidding

2023-12-06T05:23:52Z

Schen76: /* Implemented Code */

CSC/ECE 517 Fall 2023 - E2360. View for Results of Bidding

2023-12-06T05:05:25Z

Schen76: /* Implemented Code */

CSC/ECE 517 Fall 2023 - E2360. View for Results of Bidding (Phase2)

2023-12-06T04:59:02Z

Schen76: /* Code Effort */

== Motivation ==

The bidding view is needed because we don’t have a way of finding out whether the bidding algorithm is running correctly. This project is to add a bidding view to show how the topics are assigned to those teams who bid.

== Work Plan ==

Based on the project's objectives and feedback received from our mentor, we have identified specific areas for improvement:

1) Refactor variable names within methods such as "bidding_details" and variables like "Topic name" and "Bidding teams" to enhance clarity and specificity.

2) Adjust capitalization for certain components, ensuring that only the first word is capitalized for consistency.

3) Introduce calculations to determine percentages based on additional data, such as the total number of teams and the number of teams for each priority, within the "lottery_controller."

4) Conduct thorough testing of the modified controller and view to ensure optimal functionality.

[[File:Newfeature.jpg | 888px]]

To add functionality for showing the percentages of the number of teams that got their #1, #2, and #3 choices. We can follow these high-level steps:

'''Lottery_Controller:'''

i) Calculate the Total Number of Teams: Before we can calculate percentages, we need to know the total number of teams that participated in the bidding process. This will be our denominator in the percentage calculation.

ii) Calculate the Number of Teams for Each Priority: From our `bidding_details` method, we already have counts for how many teams bid on each topic as their #1, #2, and #3 choice (`@count1`, `@count2`, `@count3`). However, these counts are currently organized by topic. We would need to modify this to count how many teams got their #1, #2, and #3 choices as their assigned topic.

iii) Calculate Percentages: Once we have the number of teams that got their #1, #2, and #3 choices, we can calculate the percentages by dividing these numbers by the total number of teams and multiplying by 100.

'''Bidding_detail view:'''

i) Update the View and Display Percentages: Above the table in our previous view, we can add a section to display these percentages.

ii) Format the Display: We will use a bold heading for each percentage type and format the number to a fixed number of decimal places.

iii) Ensure Responsiveness: Make sure the display of these percentages adjusts well to different screen sizes, maintaining readability and layout consistency.

== Code Effort ==

Change in <code> app/controllers/lottery_controller.rb </code>

'''method 1: bidding_table_for_each_topic'''

This method generates a bidding table for each topic within an assignment. It performs several operations to gather and organize data related to topics, bids, and teams. Here's a breakdown of what the code does:

1. Fetch Assignment:

*It retrieves the assignment with the specified params[:id] from the database and stores it in the @assignment instance variable.

2. Fetch Topics:

*It retrieves all sign-up topics associated with the assignment and stores them in the @topics instance variable.

3. Fetch Bids and Assigned Teams:

For each topic in @topics, it:
*Retrieves all bids associated with that topic and stores them in a hash, where the key is the topic's ID and the value is an array of bids with their associated teams and priorities.
*Retrieves teams that are not waitlisted for the topic and stores them in a hash, again using the topic's ID as the key and an array of teams as the value.

4. Priority Count Calculation:

*It dynamically calculates and updates the counts for each bid priority level (1, 2, and 3) for each topic. These counts are stored in instance variables named @count1, @count2, and @count3. These instance variables are hashes where the keys are topic IDs, and the values are counts for each priority level.

5. Calculate Total Teams:

*It determines the total number of teams across all topics in the assignment by counting distinct team IDs among all non-waitlisted teams for the specified topics.

6. Calculate Priority Counts and Percentages:

*It calls two helper methods, calculate_priority_counts and calculate_percentages, to calculate the total counts of teams at each priority level and the corresponding percentages. The results are stored in the @priority_counts and @percentages instance variables, respectively.

<pre>
# Prepares data for displaying the bidding details for each topic within an assignment.
# It calculates the number of bids for each priority (1, 2, 3) per topic and also computes
# the overall percentages of teams that received their first, second, and third choice.
def bidding_table_for_each_topic
@assignment = Assignment.find(params[:id])
# Fetch all topics for the assignment
@topics = @assignment.sign_up_topics
# Fetch all bids for these topics
@bids_by_topic = {}
@assigned_teams_by_topic = {} # This will store the assigned teams for each topic
@topics.each do |topic|
# Assuming bids are stored with a topic_id, and each bid has a team associated with it
@bids_by_topic[topic.id] = Bid.where(topic_id: topic.id).map { |bid| { team: bid.team, priority: bid.priority } }
# Fetch teams that are not waitlisted for this topic
@assigned_teams_by_topic[topic.id] = SignedUpTeam.where(topic_id: topic.id, is_waitlisted: false).map(&:team)
# @count1[topic.id] += @bids_by_topic[topic.id].count { |bid| bid[:priority] == 1 }
# @count2[topic.id] += @bids_by_topic[topic.id].count { |bid| bid[:priority] == 2 }
# @count3[topic.id] += @bids_by_topic[topic.id].count { |bid| bid[:priority] == 3 }

# Dynamically initializing and updating @count1, @count2, and @count3
(1..3).each do |priority|
instance_variable_set("@count#{priority}", Hash.new(0)) unless instance_variable_defined?("@count#{priority}")
instance_variable_get("@count#{priority}")[topic.id] = @bids_by_topic[topic.id].count { |bid| bid[:priority] == priority }
end
end
# Calculate the total number of teams and percentages after fetching bid details
topic_ids = SignUpTopic.where(assignment_id: @assignment.id).pluck(:id)
@total_teams = SignedUpTeam.where(topic_id: topic_ids).distinct.count(:team_id)
@priority_counts = calculate_priority_counts(@assigned_teams_by_topic, @bids_by_topic)
@percentages = calculate_percentages(@priority_counts, @total_teams)

end
</pre>

'''method 2: calculate_priority_counts'''

1. Parameters
*assigned_teams_by_topic (Hash): A hash mapping each topic to an array of assigned teams.
*bids_by_topic (Hash): A hash mapping each topic to an array of bid objects, where each bid object is a hash containing team and priority information.

2. Functionality
*Initial Setup: Initializes a hash priority_counts with keys 1, 2, and 3, each having an initial value of 0. These keys represent the priority levels, and their values count the number of teams assigned to each level.

*Iterating Over Topics and Teams: Iterates over each topic and its associated teams found in assigned_teams_by_topic. For each team in a topic, the method searches bids_by_topic[topic_id] to find a bid made by the team.

*Updating Priority Counts: If a bid is found, the method increments the count in priority_counts corresponding to the priority level in the bid. This process effectively tallies the number of teams assigned to each priority level.

3. Returns
*priority_counts (Hash): A hash with keys 1, 2, and 3, where each key's value represents the count of teams assigned to that respective priority level.

<pre>
# Calculates the count of assigned teams for each priority level (1, 2, 3) across all topics.
# It checks each team associated with a topic and determines if the team's bid matches
# one of the priority levels, incrementing the respective count if so.
def calculate_priority_counts(assigned_teams_by_topic, bids_by_topic)
priority_counts = { 1 => 0, 2 => 0, 3 => 0 }
assigned_teams_by_topic.each do |topic_id, teams|
teams.each do |team|
bid_info = bids_by_topic[topic_id].find { |bid| bid[:team] == team }
priority_counts[bid_info[:priority]] += 1 if bid_info
end
end
priority_counts
end
</pre>

'''method 3: calculate_percentages'''

* This method calculates the percentages of teams that received their first, second, and third choice based on the counts of teams at each priority level.

<pre>
# Calculates the percentages of teams that received their first, second, and third choice
# based on the counts of teams at each priority level.
def calculate_percentages(priority_counts, total_teams)
priority_counts.transform_values { |count| (count.to_f / total_teams * 100).round(2) }
end
</pre>

Change in <code> app/views/lottery/bidding_table_for_each_topic.html.erb </code>

[[File:bidding_percentage.png | 888px]]

Components:

1. Bidding Details Header

*Displays the name of the assignment dynamically using <%= @assignment.name %>.
*This is enclosed in an "h3" tag, emphasizing its importance as the page's main title.

2. Percentage Display Section

*This section is styled with a border, padding, and a background color to make it visually distinct.
*It contains a subtitle (h4) describing the content: "Percentage of Teams Getting Their Choices."
*A list (ul) displays the percentages of teams that received their 1st, 2nd, and 3rd choice. These percentages are pulled dynamically from @percentages array.
*The colors of the percentage values vary based on the choice priority (green for #1, orange for #2, and red for #3).
Custom CSS Styles

3. Two CSS classes are defined:

*.assigned-team: Styles elements with a yellow background and black text.
*.bids-column: Sets a fixed width for columns in the table.

4. Bidding Details Table

*A table with headers for Topic Name, Topic ID, Bidding Teams, and bids.
*The table body (<tbody>) dynamically generates rows for each topic using a loop (<% @topics.each do |topic| %>).
*For each topic, the table displays its name, ID, bidding teams, and the number of bids for each choice.
*Teams are marked with the .assigned-team class if they are assigned to the topic.
*Bid counts are displayed, with a placeholder ("–") if the count is zero.

5. Navigation

*A link allowing users to navigate back to the previous page using JavaScript's history.back() function.

<pre>
<h3>Bidding Details for <%= @assignment.name %></h3>

<div class="percentages" style="margin-bottom: 20px; padding: 15px; border: 1px solid
#ccc; border-radius: 5px; background-color: #f9f9f9;">
<h4 style="margin-bottom: 15px; border-bottom: 1px solid #eee;
padding-bottom: 10px;">Percentage of Teams Getting Their Choices:</h4>
<ul style="list-style: none; padding: 0;">
<li><strong>#1 Choice:</strong> <span style="color: #4CAF50;"><%= @percentages[1] || 0 %> %</span></li>
<li><strong>#2 Choice:</strong> <span style="color: #FF9800;"><%= @percentages[2] || 0 %> %</span></li>
<li><strong>#3 Choice:</strong> <span style="color: #F44336;"><%= @percentages[3] || 0 %> %</span></li>
</ul>
</div>

<style>
.assigned-team {
background-color: yellow;
color: black;
}
.bids-column {
width: 100px; /* Adjust width as needed */
}
</style>

<table class="table table-bordered table-hover">
<thead>
<tr>
<th>Topic Name</th>
<th>Topic ID</th>
<th>Bidding Teams</th>
<th>#1 bids</th>
<th>#2 bids</th>
<th>#3 bids</th>
</tr>
</thead>
<tbody>
<% @topics.each do |topic| %>
<tr>
<td><%= topic.topic_name %></td>
<td><%= topic.id %></td>
<td>
<% @bids_by_topic[topic.id].each do |bid_info| %>
<% team = bid_info[:team] %>
<% assigned_team = @assigned_teams_by_topic[topic.id].include?(team) %>
<span class="<%= assigned_team ? 'assigned-team' : '' %>">
<%= team.name %> (#<%= bid_info[:priority] %>)
</span>
<% end %>
</td>
<td class="bids-column">
<% if @count1[topic.id] != 0%>
<%= @count1[topic.id] %>
<%else%>
–
<%end%>
</td>
<td class="bids-column">
<% if @count2[topic.id] != 0%>
<%= @count2[topic.id] %>
<%else%>
–
<%end%>
</td>
<td class="bids-column">
<% if @count3[topic.id] != 0%>
<%= @count3[topic.id] %>
<%else%>
–
<%end%>
</td>
</tr>
<% end %>
</tbody>
</table>

<a href="javascript:history.back()">Back</a>
</pre>

== Testing ==

1. Test for Populating Bids and Assigned Teams:
*This test ensures that the bidding_table_for_each_topic method correctly populates bids and assigned teams for each topic.
*It checks if @bids_by_topic is populated correctly, verifying the length of bids for specific topics.
*It tests @assigned_teams_by_topic, ensuring it handles cases where topics have no teams.

2. Test for Fetching All Topics:
*This test verifies that all topics for the assignment are fetched and stored in @topics.

3. Test for Calculating Priority Counts:
*This test checks the calculation of priority counts for each topic.
*It compares the calculated priority counts against an expected set of values.

4. Test for Calculating Percentages for Teams Getting Their Choices:
*This test ensures that the method correctly calculates the percentages of teams getting their preferred choices.
*It handles special cases where the expected percentages are not a number (NaN).

Rspec Testing <code> app/views/lottery/bidding_table_for_each_topic.html.erb </code>

<pre>
describe '#bidding_table_for_each_topic' do
before :each do
# Set the assignment id in the params
params = ActionController::Parameters.new(id: assignment.id)
allow(controller).to receive(:params).and_return(params)
end
it 'populates bids and assigned teams for each topic, handling topics with no teams' do
controller.bidding_table_for_each_topic
# Check if @bids_by_topic is populated correctly
expect(controller.instance_variable_get(:@bids_by_topic)[topic1.id].length).to eq(1)
expect(controller.instance_variable_get(:@bids_by_topic)[topic2.id].length).to eq(1)
# Check if @assigned_teams_by_topic is populated correctly, allowing for no teams
assigned_teams_topic1 = controller.instance_variable_get(:@assigned_teams_by_topic)[topic1.id]
if assigned_teams_topic1
expect(assigned_teams_topic1.length).to(satisfy { |value| (value == 0) || (value == 1) })
else
expect(assigned_teams_topic1).to be_nil
end
# Check the counts of bids for each priority level
# Ensure to adjust these based on what is set up in your test data
expect(controller.instance_variable_get(:@count1)[topic1.id]).to eq(1)
# assuming there is one bid with priority 1 for topic1
expect(controller.instance_variable_get(:@count2)[topic1.id]).to eq(0)
# assuming there are no bids with priority 2 for topic1
expect(controller.instance_variable_get(:@count3)[topic1.id]).to eq(0)
# assuming there are no bids with priority 3 for topic1
end

it 'fetches all topics for the assignment' do
controller.bidding_table_for_each_topic
expect(controller.instance_variable_get(:@topics)).to match_array([topic1, topic2, topic3, topic4])
end

it 'correctly calculates priority counts for each topic' do
controller.bidding_table_for_each_topic

# Assuming you have a way to know the expected counts for each priority
expected_priority_counts = { 1 => 0,
2 => 0,
3 => 0 }

priority_counts = controller.instance_variable_get(:@priority_counts)
expect(priority_counts).to eq(expected_priority_counts)
end

it 'correctly calculates percentages for teams getting their choices' do
controller.bidding_table_for_each_topic

# Assuming you have a way to know the expected percentages
expected_percentages = { 1 => Float::NAN,
2 => Float::NAN,
3 => Float::NAN }

percentages = controller.instance_variable_get(:@percentages)
expect(percentages[1].nan?).to be true if expected_percentages[1].nan?
expect(percentages[2].nan?).to be true if expected_percentages[2].nan?
expect(percentages[3].nan?).to be true if expected_percentages[3].nan?
end
end
end
</pre>

== Relevant Links ==

'''Github Repository: ''' https://github.com/Shreshth-Malik/expertiza

'''Demo Video:''' https://www.youtube.com/watch?v=pGmHyqLj7PM

== Testing Credentials ==

username: instructor6

password: password

== Team ==
'''Mentor'''

Edward F. Gehringer (efg@ncsu.edu)

'''Members'''

Richard Li (rli14@ncsu.edu)

Shreshth Malik (smalik4@ncsu.edu)

Shuai Chen (schen76@ncsu.edu)

CSC/ECE 517 Fall 2023 - E2360. View for Results of Bidding (Phase2)

2023-12-06T04:34:18Z

Schen76: /* Relevant Links */

== Motivation ==

The bidding view is needed because we don’t have a way of finding out whether the bidding algorithm is running correctly. This project is to add a bidding view to show how the topics are assigned to those teams who bid.

== Work Plan ==

Based on the project's objectives and feedback received from our mentor, we have identified specific areas for improvement:

1) Refactor variable names within methods such as "bidding_details" and variables like "Topic name" and "Bidding teams" to enhance clarity and specificity.

2) Adjust capitalization for certain components, ensuring that only the first word is capitalized for consistency.

3) Introduce calculations to determine percentages based on additional data, such as the total number of teams and the number of teams for each priority, within the "lottery_controller."

4) Conduct thorough testing of the modified controller and view to ensure optimal functionality.

[[File:Newfeature.jpg | 888px]]

To add functionality for showing the percentages of the number of teams that got their #1, #2, and #3 choices. We can follow these high-level steps:

'''Lottery_Controller:'''

i) Calculate the Total Number of Teams: Before we can calculate percentages, we need to know the total number of teams that participated in the bidding process. This will be our denominator in the percentage calculation.

ii) Calculate the Number of Teams for Each Priority: From our `bidding_details` method, we already have counts for how many teams bid on each topic as their #1, #2, and #3 choice (`@count1`, `@count2`, `@count3`). However, these counts are currently organized by topic. We would need to modify this to count how many teams got their #1, #2, and #3 choices as their assigned topic.

iii) Calculate Percentages: Once we have the number of teams that got their #1, #2, and #3 choices, we can calculate the percentages by dividing these numbers by the total number of teams and multiplying by 100.

'''Bidding_detail view:'''

i) Update the View and Display Percentages: Above the table in our previous view, we can add a section to display these percentages.

ii) Format the Display: We will use a bold heading for each percentage type and format the number to a fixed number of decimal places.

iii) Ensure Responsiveness: Make sure the display of these percentages adjusts well to different screen sizes, maintaining readability and layout consistency.

== Code Effort ==

Change in <code> app/controllers/lottery_controller.rb </code>

'''method 1: bidding_table_for_each_topic'''

This method generates a bidding table for each topic within an assignment. It performs several operations to gather and organize data related to topics, bids, and teams. Here's a breakdown of what the code does:

1. Fetch Assignment:

*It retrieves the assignment with the specified params[:id] from the database and stores it in the @assignment instance variable.

2. Fetch Topics:

*It retrieves all sign-up topics associated with the assignment and stores them in the @topics instance variable.

3. Fetch Bids and Assigned Teams:

For each topic in @topics, it:
*Retrieves all bids associated with that topic and stores them in a hash, where the key is the topic's ID and the value is an array of bids with their associated teams and priorities.
*Retrieves teams that are not waitlisted for the topic and stores them in a hash, again using the topic's ID as the key and an array of teams as the value.

4. Priority Count Calculation:

*It dynamically calculates and updates the counts for each bid priority level (1, 2, and 3) for each topic. These counts are stored in instance variables named @count1, @count2, and @count3. These instance variables are hashes where the keys are topic IDs, and the values are counts for each priority level.

5. Calculate Total Teams:

*It determines the total number of teams across all topics in the assignment by counting distinct team IDs among all non-waitlisted teams for the specified topics.

6. Calculate Priority Counts and Percentages:

*It calls two helper methods, calculate_priority_counts and calculate_percentages, to calculate the total counts of teams at each priority level and the corresponding percentages. The results are stored in the @priority_counts and @percentages instance variables, respectively.

<pre>
# Prepares data for displaying the bidding details for each topic within an assignment.
# It calculates the number of bids for each priority (1, 2, 3) per topic and also computes
# the overall percentages of teams that received their first, second, and third choice.
def bidding_table_for_each_topic
@assignment = Assignment.find(params[:id])
# Fetch all topics for the assignment
@topics = @assignment.sign_up_topics
# Fetch all bids for these topics
@bids_by_topic = {}
@assigned_teams_by_topic = {} # This will store the assigned teams for each topic
@topics.each do |topic|
# Assuming bids are stored with a topic_id, and each bid has a team associated with it
@bids_by_topic[topic.id] = Bid.where(topic_id: topic.id).map { |bid| { team: bid.team, priority: bid.priority } }
# Fetch teams that are not waitlisted for this topic
@assigned_teams_by_topic[topic.id] = SignedUpTeam.where(topic_id: topic.id, is_waitlisted: false).map(&:team)
# @count1[topic.id] += @bids_by_topic[topic.id].count { |bid| bid[:priority] == 1 }
# @count2[topic.id] += @bids_by_topic[topic.id].count { |bid| bid[:priority] == 2 }
# @count3[topic.id] += @bids_by_topic[topic.id].count { |bid| bid[:priority] == 3 }

# Dynamically initializing and updating @count1, @count2, and @count3
(1..3).each do |priority|
instance_variable_set("@count#{priority}", Hash.new(0)) unless instance_variable_defined?("@count#{priority}")
instance_variable_get("@count#{priority}")[topic.id] = @bids_by_topic[topic.id].count { |bid| bid[:priority] == priority }
end
end
# Calculate the total number of teams and percentages after fetching bid details
topic_ids = SignUpTopic.where(assignment_id: @assignment.id).pluck(:id)
@total_teams = SignedUpTeam.where(topic_id: topic_ids).distinct.count(:team_id)
@priority_counts = calculate_priority_counts(@assigned_teams_by_topic, @bids_by_topic)
@percentages = calculate_percentages(@priority_counts, @total_teams)

end
</pre>

'''method 2: calculate_priority_counts'''

1. Parameters
*assigned_teams_by_topic (Hash): A hash mapping each topic to an array of assigned teams.
*bids_by_topic (Hash): A hash mapping each topic to an array of bid objects, where each bid object is a hash containing team and priority information.

2. Functionality
*Initial Setup: Initializes a hash priority_counts with keys 1, 2, and 3, each having an initial value of 0. These keys represent the priority levels, and their values count the number of teams assigned to each level.

*Iterating Over Topics and Teams: Iterates over each topic and its associated teams found in assigned_teams_by_topic. For each team in a topic, the method searches bids_by_topic[topic_id] to find a bid made by the team.

*Updating Priority Counts: If a bid is found, the method increments the count in priority_counts corresponding to the priority level in the bid. This process effectively tallies the number of teams assigned to each priority level.

3. Returns
*priority_counts (Hash): A hash with keys 1, 2, and 3, where each key's value represents the count of teams assigned to that respective priority level.

<pre>
# Calculates the count of assigned teams for each priority level (1, 2, 3) across all topics.
# It checks each team associated with a topic and determines if the team's bid matches
# one of the priority levels, incrementing the respective count if so.
def calculate_priority_counts(assigned_teams_by_topic, bids_by_topic)
priority_counts = { 1 => 0, 2 => 0, 3 => 0 }
assigned_teams_by_topic.each do |topic_id, teams|
teams.each do |team|
bid_info = bids_by_topic[topic_id].find { |bid| bid[:team] == team }
priority_counts[bid_info[:priority]] += 1 if bid_info
end
end
priority_counts
end
</pre>

'''method 3: calculate_percentages'''

* This method calculates the percentages of teams that received their first, second, and third choice based on the counts of teams at each priority level.

<pre>
# Calculates the percentages of teams that received their first, second, and third choice
# based on the counts of teams at each priority level.
def calculate_percentages(priority_counts, total_teams)
priority_counts.transform_values { |count| (count.to_f / total_teams * 100).round(2) }
end
</pre>

Change in <code> app/views/lottery/bidding_table_for_each_topic.html.erb </code>

[[File:bidding_percentage.png | 888px]]

<pre>
<h3>Bidding Details for <%= @assignment.name %></h3>

<div class="percentages" style="margin-bottom: 20px; padding: 15px; border: 1px solid
#ccc; border-radius: 5px; background-color: #f9f9f9;">
<h4 style="margin-bottom: 15px; border-bottom: 1px solid #eee;
padding-bottom: 10px;">Percentage of Teams Getting Their Choices:</h4>
<ul style="list-style: none; padding: 0;">
<li><strong>#1 Choice:</strong> <span style="color: #4CAF50;"><%= @percentages[1] || 0 %> %</span></li>
<li><strong>#2 Choice:</strong> <span style="color: #FF9800;"><%= @percentages[2] || 0 %> %</span></li>
<li><strong>#3 Choice:</strong> <span style="color: #F44336;"><%= @percentages[3] || 0 %> %</span></li>
</ul>
</div>

<style>
.assigned-team {
background-color: yellow;
color: black;
}
.bids-column {
width: 100px; /* Adjust width as needed */
}
</style>

<table class="table table-bordered table-hover">
<thead>
<tr>
<th>Topic Name</th>
<th>Topic ID</th>
<th>Bidding Teams</th>
<th>#1 bids</th>
<th>#2 bids</th>
<th>#3 bids</th>
</tr>
</thead>
<tbody>
<% @topics.each do |topic| %>
<tr>
<td><%= topic.topic_name %></td>
<td><%= topic.id %></td>
<td>
<% @bids_by_topic[topic.id].each do |bid_info| %>
<% team = bid_info[:team] %>
<% assigned_team = @assigned_teams_by_topic[topic.id].include?(team) %>
<span class="<%= assigned_team ? 'assigned-team' : '' %>">
<%= team.name %> (#<%= bid_info[:priority] %>)
</span>
<% end %>
</td>
<td class="bids-column">
<% if @count1[topic.id] != 0%>
<%= @count1[topic.id] %>
<%else%>
–
<%end%>
</td>
<td class="bids-column">
<% if @count2[topic.id] != 0%>
<%= @count2[topic.id] %>
<%else%>
–
<%end%>
</td>
<td class="bids-column">
<% if @count3[topic.id] != 0%>
<%= @count3[topic.id] %>
<%else%>
–
<%end%>
</td>
</tr>
<% end %>
</tbody>
</table>

<a href="javascript:history.back()">Back</a>
</pre>

== Testing ==

1. Test for Populating Bids and Assigned Teams:
*This test ensures that the bidding_table_for_each_topic method correctly populates bids and assigned teams for each topic.
*It checks if @bids_by_topic is populated correctly, verifying the length of bids for specific topics.
*It tests @assigned_teams_by_topic, ensuring it handles cases where topics have no teams.

2. Test for Fetching All Topics:
*This test verifies that all topics for the assignment are fetched and stored in @topics.

3. Test for Calculating Priority Counts:
*This test checks the calculation of priority counts for each topic.
*It compares the calculated priority counts against an expected set of values.

4. Test for Calculating Percentages for Teams Getting Their Choices:
*This test ensures that the method correctly calculates the percentages of teams getting their preferred choices.
*It handles special cases where the expected percentages are not a number (NaN).

Rspec Testing <code> app/views/lottery/bidding_table_for_each_topic.html.erb </code>

<pre>
describe '#bidding_table_for_each_topic' do
before :each do
# Set the assignment id in the params
params = ActionController::Parameters.new(id: assignment.id)
allow(controller).to receive(:params).and_return(params)
end
it 'populates bids and assigned teams for each topic, handling topics with no teams' do
controller.bidding_table_for_each_topic
# Check if @bids_by_topic is populated correctly
expect(controller.instance_variable_get(:@bids_by_topic)[topic1.id].length).to eq(1)
expect(controller.instance_variable_get(:@bids_by_topic)[topic2.id].length).to eq(1)
# Check if @assigned_teams_by_topic is populated correctly, allowing for no teams
assigned_teams_topic1 = controller.instance_variable_get(:@assigned_teams_by_topic)[topic1.id]
if assigned_teams_topic1
expect(assigned_teams_topic1.length).to(satisfy { |value| (value == 0) || (value == 1) })
else
expect(assigned_teams_topic1).to be_nil
end
# Check the counts of bids for each priority level
# Ensure to adjust these based on what is set up in your test data
expect(controller.instance_variable_get(:@count1)[topic1.id]).to eq(1)
# assuming there is one bid with priority 1 for topic1
expect(controller.instance_variable_get(:@count2)[topic1.id]).to eq(0)
# assuming there are no bids with priority 2 for topic1
expect(controller.instance_variable_get(:@count3)[topic1.id]).to eq(0)
# assuming there are no bids with priority 3 for topic1
end

it 'fetches all topics for the assignment' do
controller.bidding_table_for_each_topic
expect(controller.instance_variable_get(:@topics)).to match_array([topic1, topic2, topic3, topic4])
end

it 'correctly calculates priority counts for each topic' do
controller.bidding_table_for_each_topic

# Assuming you have a way to know the expected counts for each priority
expected_priority_counts = { 1 => 0,
2 => 0,
3 => 0 }

priority_counts = controller.instance_variable_get(:@priority_counts)
expect(priority_counts).to eq(expected_priority_counts)
end

it 'correctly calculates percentages for teams getting their choices' do
controller.bidding_table_for_each_topic

# Assuming you have a way to know the expected percentages
expected_percentages = { 1 => Float::NAN,
2 => Float::NAN,
3 => Float::NAN }

percentages = controller.instance_variable_get(:@percentages)
expect(percentages[1].nan?).to be true if expected_percentages[1].nan?
expect(percentages[2].nan?).to be true if expected_percentages[2].nan?
expect(percentages[3].nan?).to be true if expected_percentages[3].nan?
end
end
end
</pre>

== Relevant Links ==

'''Github Repository: ''' https://github.com/Shreshth-Malik/expertiza

'''Demo Video:''' https://www.youtube.com/watch?v=pGmHyqLj7PM

== Testing Credentials ==

username: instructor6

password: password

== Team ==
'''Mentor'''

Edward F. Gehringer (efg@ncsu.edu)

'''Members'''

Richard Li (rli14@ncsu.edu)

Shreshth Malik (smalik4@ncsu.edu)

Shuai Chen (schen76@ncsu.edu)

CSC/ECE 517 Fall 2023 - E2360. View for Results of Bidding (Phase2)

2023-12-05T07:54:20Z

Schen76: /* Testing */

== Motivation ==

The bidding view is needed because we don’t have a way of finding out whether the bidding algorithm is running correctly. This project is to add a bidding view to show how the topics are assigned to those teams who bid.

== Work Plan ==

Based on the project's objectives and feedback received from our mentor, we have identified specific areas for improvement:

1) Refactor variable names within methods such as "bidding_details" and variables like "Topic name" and "Bidding teams" to enhance clarity and specificity.

2) Adjust capitalization for certain components, ensuring that only the first word is capitalized for consistency.

3) Introduce calculations to determine percentages based on additional data, such as the total number of teams and the number of teams for each priority, within the "lottery_controller."

4) Conduct thorough testing of the modified controller and view to ensure optimal functionality.

[[File:Newfeature.jpg | 888px]]

To add functionality for showing the percentages of the number of teams that got their #1, #2, and #3 choices. We can follow these high-level steps:

'''Lottery_Controller:'''

i) Calculate the Total Number of Teams: Before we can calculate percentages, we need to know the total number of teams that participated in the bidding process. This will be our denominator in the percentage calculation.

ii) Calculate the Number of Teams for Each Priority: From our `bidding_details` method, we already have counts for how many teams bid on each topic as their #1, #2, and #3 choice (`@count1`, `@count2`, `@count3`). However, these counts are currently organized by topic. We would need to modify this to count how many teams got their #1, #2, and #3 choices as their assigned topic.

iii) Calculate Percentages: Once we have the number of teams that got their #1, #2, and #3 choices, we can calculate the percentages by dividing these numbers by the total number of teams and multiplying by 100.

'''Bidding_detail view:'''

i) Update the View and Display Percentages: Above the table in our previous view, we can add a section to display these percentages.

ii) Format the Display: We will use a bold heading for each percentage type and format the number to a fixed number of decimal places.

iii) Ensure Responsiveness: Make sure the display of these percentages adjusts well to different screen sizes, maintaining readability and layout consistency.

== Code Effort ==

Change in <code> app/controllers/lottery_controller.rb </code>

'''method 1: bidding_table_for_each_topic'''

This method generates a bidding table for each topic within an assignment. It performs several operations to gather and organize data related to topics, bids, and teams. Here's a breakdown of what the code does:

1. Fetch Assignment:

*It retrieves the assignment with the specified params[:id] from the database and stores it in the @assignment instance variable.

2. Fetch Topics:

*It retrieves all sign-up topics associated with the assignment and stores them in the @topics instance variable.

3. Fetch Bids and Assigned Teams:

For each topic in @topics, it:
*Retrieves all bids associated with that topic and stores them in a hash, where the key is the topic's ID and the value is an array of bids with their associated teams and priorities.
*Retrieves teams that are not waitlisted for the topic and stores them in a hash, again using the topic's ID as the key and an array of teams as the value.

4. Priority Count Calculation:

*It dynamically calculates and updates the counts for each bid priority level (1, 2, and 3) for each topic. These counts are stored in instance variables named @count1, @count2, and @count3. These instance variables are hashes where the keys are topic IDs, and the values are counts for each priority level.

5. Calculate Total Teams:

*It determines the total number of teams across all topics in the assignment by counting distinct team IDs among all non-waitlisted teams for the specified topics.

6. Calculate Priority Counts and Percentages:

*It calls two helper methods, calculate_priority_counts and calculate_percentages, to calculate the total counts of teams at each priority level and the corresponding percentages. The results are stored in the @priority_counts and @percentages instance variables, respectively.

<pre>
# Prepares data for displaying the bidding details for each topic within an assignment.
# It calculates the number of bids for each priority (1, 2, 3) per topic and also computes
# the overall percentages of teams that received their first, second, and third choice.
def bidding_table_for_each_topic
@assignment = Assignment.find(params[:id])
# Fetch all topics for the assignment
@topics = @assignment.sign_up_topics
# Fetch all bids for these topics
@bids_by_topic = {}
@assigned_teams_by_topic = {} # This will store the assigned teams for each topic
@topics.each do |topic|
# Assuming bids are stored with a topic_id, and each bid has a team associated with it
@bids_by_topic[topic.id] = Bid.where(topic_id: topic.id).map { |bid| { team: bid.team, priority: bid.priority } }
# Fetch teams that are not waitlisted for this topic
@assigned_teams_by_topic[topic.id] = SignedUpTeam.where(topic_id: topic.id, is_waitlisted: false).map(&:team)
# @count1[topic.id] += @bids_by_topic[topic.id].count { |bid| bid[:priority] == 1 }
# @count2[topic.id] += @bids_by_topic[topic.id].count { |bid| bid[:priority] == 2 }
# @count3[topic.id] += @bids_by_topic[topic.id].count { |bid| bid[:priority] == 3 }

# Dynamically initializing and updating @count1, @count2, and @count3
(1..3).each do |priority|
instance_variable_set("@count#{priority}", Hash.new(0)) unless instance_variable_defined?("@count#{priority}")
instance_variable_get("@count#{priority}")[topic.id] = @bids_by_topic[topic.id].count { |bid| bid[:priority] == priority }
end
end
# Calculate the total number of teams and percentages after fetching bid details
topic_ids = SignUpTopic.where(assignment_id: @assignment.id).pluck(:id)
@total_teams = SignedUpTeam.where(topic_id: topic_ids).distinct.count(:team_id)
@priority_counts = calculate_priority_counts(@assigned_teams_by_topic, @bids_by_topic)
@percentages = calculate_percentages(@priority_counts, @total_teams)

end
</pre>

'''method 2: calculate_priority_counts'''

1. Parameters
*assigned_teams_by_topic (Hash): A hash mapping each topic to an array of assigned teams.
*bids_by_topic (Hash): A hash mapping each topic to an array of bid objects, where each bid object is a hash containing team and priority information.

2. Functionality
*Initial Setup: Initializes a hash priority_counts with keys 1, 2, and 3, each having an initial value of 0. These keys represent the priority levels, and their values count the number of teams assigned to each level.

*Iterating Over Topics and Teams: Iterates over each topic and its associated teams found in assigned_teams_by_topic. For each team in a topic, the method searches bids_by_topic[topic_id] to find a bid made by the team.

*Updating Priority Counts: If a bid is found, the method increments the count in priority_counts corresponding to the priority level in the bid. This process effectively tallies the number of teams assigned to each priority level.

3. Returns
*priority_counts (Hash): A hash with keys 1, 2, and 3, where each key's value represents the count of teams assigned to that respective priority level.

<pre>
# Calculates the count of assigned teams for each priority level (1, 2, 3) across all topics.
# It checks each team associated with a topic and determines if the team's bid matches
# one of the priority levels, incrementing the respective count if so.
def calculate_priority_counts(assigned_teams_by_topic, bids_by_topic)
priority_counts = { 1 => 0, 2 => 0, 3 => 0 }
assigned_teams_by_topic.each do |topic_id, teams|
teams.each do |team|
bid_info = bids_by_topic[topic_id].find { |bid| bid[:team] == team }
priority_counts[bid_info[:priority]] += 1 if bid_info
end
end
priority_counts
end
</pre>

'''method 3: calculate_percentages'''

* This method calculates the percentages of teams that received their first, second, and third choice based on the counts of teams at each priority level.

<pre>
# Calculates the percentages of teams that received their first, second, and third choice
# based on the counts of teams at each priority level.
def calculate_percentages(priority_counts, total_teams)
priority_counts.transform_values { |count| (count.to_f / total_teams * 100).round(2) }
end
</pre>

Change in <code> app/views/lottery/bidding_table_for_each_topic.html.erb </code>

[[File:bidding_percentage.png | 888px]]

<pre>
<h3>Bidding Details for <%= @assignment.name %></h3>

<div class="percentages" style="margin-bottom: 20px; padding: 15px; border: 1px solid
#ccc; border-radius: 5px; background-color: #f9f9f9;">
<h4 style="margin-bottom: 15px; border-bottom: 1px solid #eee;
padding-bottom: 10px;">Percentage of Teams Getting Their Choices:</h4>
<ul style="list-style: none; padding: 0;">
<li><strong>#1 Choice:</strong> <span style="color: #4CAF50;"><%= @percentages[1] || 0 %> %</span></li>
<li><strong>#2 Choice:</strong> <span style="color: #FF9800;"><%= @percentages[2] || 0 %> %</span></li>
<li><strong>#3 Choice:</strong> <span style="color: #F44336;"><%= @percentages[3] || 0 %> %</span></li>
</ul>
</div>

<style>
.assigned-team {
background-color: yellow;
color: black;
}
.bids-column {
width: 100px; /* Adjust width as needed */
}
</style>

<table class="table table-bordered table-hover">
<thead>
<tr>
<th>Topic Name</th>
<th>Topic ID</th>
<th>Bidding Teams</th>
<th>#1 bids</th>
<th>#2 bids</th>
<th>#3 bids</th>
</tr>
</thead>
<tbody>
<% @topics.each do |topic| %>
<tr>
<td><%= topic.topic_name %></td>
<td><%= topic.id %></td>
<td>
<% @bids_by_topic[topic.id].each do |bid_info| %>
<% team = bid_info[:team] %>
<% assigned_team = @assigned_teams_by_topic[topic.id].include?(team) %>
<span class="<%= assigned_team ? 'assigned-team' : '' %>">
<%= team.name %> (#<%= bid_info[:priority] %>)
</span>
<% end %>
</td>
<td class="bids-column">
<% if @count1[topic.id] != 0%>
<%= @count1[topic.id] %>
<%else%>
–
<%end%>
</td>
<td class="bids-column">
<% if @count2[topic.id] != 0%>
<%= @count2[topic.id] %>
<%else%>
–
<%end%>
</td>
<td class="bids-column">
<% if @count3[topic.id] != 0%>
<%= @count3[topic.id] %>
<%else%>
–
<%end%>
</td>
</tr>
<% end %>
</tbody>
</table>

<a href="javascript:history.back()">Back</a>
</pre>

== Testing ==

1. Test for Populating Bids and Assigned Teams:
*This test ensures that the bidding_table_for_each_topic method correctly populates bids and assigned teams for each topic.
*It checks if @bids_by_topic is populated correctly, verifying the length of bids for specific topics.
*It tests @assigned_teams_by_topic, ensuring it handles cases where topics have no teams.

2. Test for Fetching All Topics:
*This test verifies that all topics for the assignment are fetched and stored in @topics.

3. Test for Calculating Priority Counts:
*This test checks the calculation of priority counts for each topic.
*It compares the calculated priority counts against an expected set of values.

4. Test for Calculating Percentages for Teams Getting Their Choices:
*This test ensures that the method correctly calculates the percentages of teams getting their preferred choices.
*It handles special cases where the expected percentages are not a number (NaN).

Rspec Testing <code> app/views/lottery/bidding_table_for_each_topic.html.erb </code>

<pre>
describe '#bidding_table_for_each_topic' do
before :each do
# Set the assignment id in the params
params = ActionController::Parameters.new(id: assignment.id)
allow(controller).to receive(:params).and_return(params)
end
it 'populates bids and assigned teams for each topic, handling topics with no teams' do
controller.bidding_table_for_each_topic
# Check if @bids_by_topic is populated correctly
expect(controller.instance_variable_get(:@bids_by_topic)[topic1.id].length).to eq(1)
expect(controller.instance_variable_get(:@bids_by_topic)[topic2.id].length).to eq(1)
# Check if @assigned_teams_by_topic is populated correctly, allowing for no teams
assigned_teams_topic1 = controller.instance_variable_get(:@assigned_teams_by_topic)[topic1.id]
if assigned_teams_topic1
expect(assigned_teams_topic1.length).to(satisfy { |value| (value == 0) || (value == 1) })
else
expect(assigned_teams_topic1).to be_nil
end
# Check the counts of bids for each priority level
# Ensure to adjust these based on what is set up in your test data
expect(controller.instance_variable_get(:@count1)[topic1.id]).to eq(1)
# assuming there is one bid with priority 1 for topic1
expect(controller.instance_variable_get(:@count2)[topic1.id]).to eq(0)
# assuming there are no bids with priority 2 for topic1
expect(controller.instance_variable_get(:@count3)[topic1.id]).to eq(0)
# assuming there are no bids with priority 3 for topic1
end

it 'fetches all topics for the assignment' do
controller.bidding_table_for_each_topic
expect(controller.instance_variable_get(:@topics)).to match_array([topic1, topic2, topic3, topic4])
end

it 'correctly calculates priority counts for each topic' do
controller.bidding_table_for_each_topic

# Assuming you have a way to know the expected counts for each priority
expected_priority_counts = { 1 => 0,
2 => 0,
3 => 0 }

priority_counts = controller.instance_variable_get(:@priority_counts)
expect(priority_counts).to eq(expected_priority_counts)
end

it 'correctly calculates percentages for teams getting their choices' do
controller.bidding_table_for_each_topic

# Assuming you have a way to know the expected percentages
expected_percentages = { 1 => Float::NAN,
2 => Float::NAN,
3 => Float::NAN }

percentages = controller.instance_variable_get(:@percentages)
expect(percentages[1].nan?).to be true if expected_percentages[1].nan?
expect(percentages[2].nan?).to be true if expected_percentages[2].nan?
expect(percentages[3].nan?).to be true if expected_percentages[3].nan?
end
end
end
</pre>

== Relevant Links ==

'''Github Repository: ''' https://github.com/Shreshth-Malik/expertiza

== Testing Credentials ==

username: instructor6

password: password

== Team ==
'''Mentor'''

Edward F. Gehringer (efg@ncsu.edu)

'''Members'''

Richard Li (rli14@ncsu.edu)

Shreshth Malik (smalik4@ncsu.edu)

Shuai Chen (schen76@ncsu.edu)

CSC/ECE 517 Fall 2023 - E2360. View for Results of Bidding (Phase2)

2023-12-05T07:53:48Z

Schen76:

== Motivation ==

The bidding view is needed because we don’t have a way of finding out whether the bidding algorithm is running correctly. This project is to add a bidding view to show how the topics are assigned to those teams who bid.

== Work Plan ==

Based on the project's objectives and feedback received from our mentor, we have identified specific areas for improvement:

1) Refactor variable names within methods such as "bidding_details" and variables like "Topic name" and "Bidding teams" to enhance clarity and specificity.

2) Adjust capitalization for certain components, ensuring that only the first word is capitalized for consistency.

3) Introduce calculations to determine percentages based on additional data, such as the total number of teams and the number of teams for each priority, within the "lottery_controller."

4) Conduct thorough testing of the modified controller and view to ensure optimal functionality.

[[File:Newfeature.jpg | 888px]]

To add functionality for showing the percentages of the number of teams that got their #1, #2, and #3 choices. We can follow these high-level steps:

'''Lottery_Controller:'''

i) Calculate the Total Number of Teams: Before we can calculate percentages, we need to know the total number of teams that participated in the bidding process. This will be our denominator in the percentage calculation.

ii) Calculate the Number of Teams for Each Priority: From our `bidding_details` method, we already have counts for how many teams bid on each topic as their #1, #2, and #3 choice (`@count1`, `@count2`, `@count3`). However, these counts are currently organized by topic. We would need to modify this to count how many teams got their #1, #2, and #3 choices as their assigned topic.

iii) Calculate Percentages: Once we have the number of teams that got their #1, #2, and #3 choices, we can calculate the percentages by dividing these numbers by the total number of teams and multiplying by 100.

'''Bidding_detail view:'''

i) Update the View and Display Percentages: Above the table in our previous view, we can add a section to display these percentages.

ii) Format the Display: We will use a bold heading for each percentage type and format the number to a fixed number of decimal places.

iii) Ensure Responsiveness: Make sure the display of these percentages adjusts well to different screen sizes, maintaining readability and layout consistency.

== Code Effort ==

Change in <code> app/controllers/lottery_controller.rb </code>

'''method 1: bidding_table_for_each_topic'''

This method generates a bidding table for each topic within an assignment. It performs several operations to gather and organize data related to topics, bids, and teams. Here's a breakdown of what the code does:

1. Fetch Assignment:

*It retrieves the assignment with the specified params[:id] from the database and stores it in the @assignment instance variable.

2. Fetch Topics:

*It retrieves all sign-up topics associated with the assignment and stores them in the @topics instance variable.

3. Fetch Bids and Assigned Teams:

For each topic in @topics, it:
*Retrieves all bids associated with that topic and stores them in a hash, where the key is the topic's ID and the value is an array of bids with their associated teams and priorities.
*Retrieves teams that are not waitlisted for the topic and stores them in a hash, again using the topic's ID as the key and an array of teams as the value.

4. Priority Count Calculation:

*It dynamically calculates and updates the counts for each bid priority level (1, 2, and 3) for each topic. These counts are stored in instance variables named @count1, @count2, and @count3. These instance variables are hashes where the keys are topic IDs, and the values are counts for each priority level.

5. Calculate Total Teams:

*It determines the total number of teams across all topics in the assignment by counting distinct team IDs among all non-waitlisted teams for the specified topics.

6. Calculate Priority Counts and Percentages:

*It calls two helper methods, calculate_priority_counts and calculate_percentages, to calculate the total counts of teams at each priority level and the corresponding percentages. The results are stored in the @priority_counts and @percentages instance variables, respectively.

<pre>
# Prepares data for displaying the bidding details for each topic within an assignment.
# It calculates the number of bids for each priority (1, 2, 3) per topic and also computes
# the overall percentages of teams that received their first, second, and third choice.
def bidding_table_for_each_topic
@assignment = Assignment.find(params[:id])
# Fetch all topics for the assignment
@topics = @assignment.sign_up_topics
# Fetch all bids for these topics
@bids_by_topic = {}
@assigned_teams_by_topic = {} # This will store the assigned teams for each topic
@topics.each do |topic|
# Assuming bids are stored with a topic_id, and each bid has a team associated with it
@bids_by_topic[topic.id] = Bid.where(topic_id: topic.id).map { |bid| { team: bid.team, priority: bid.priority } }
# Fetch teams that are not waitlisted for this topic
@assigned_teams_by_topic[topic.id] = SignedUpTeam.where(topic_id: topic.id, is_waitlisted: false).map(&:team)
# @count1[topic.id] += @bids_by_topic[topic.id].count { |bid| bid[:priority] == 1 }
# @count2[topic.id] += @bids_by_topic[topic.id].count { |bid| bid[:priority] == 2 }
# @count3[topic.id] += @bids_by_topic[topic.id].count { |bid| bid[:priority] == 3 }

# Dynamically initializing and updating @count1, @count2, and @count3
(1..3).each do |priority|
instance_variable_set("@count#{priority}", Hash.new(0)) unless instance_variable_defined?("@count#{priority}")
instance_variable_get("@count#{priority}")[topic.id] = @bids_by_topic[topic.id].count { |bid| bid[:priority] == priority }
end
end
# Calculate the total number of teams and percentages after fetching bid details
topic_ids = SignUpTopic.where(assignment_id: @assignment.id).pluck(:id)
@total_teams = SignedUpTeam.where(topic_id: topic_ids).distinct.count(:team_id)
@priority_counts = calculate_priority_counts(@assigned_teams_by_topic, @bids_by_topic)
@percentages = calculate_percentages(@priority_counts, @total_teams)

end
</pre>

'''method 2: calculate_priority_counts'''

1. Parameters
*assigned_teams_by_topic (Hash): A hash mapping each topic to an array of assigned teams.
*bids_by_topic (Hash): A hash mapping each topic to an array of bid objects, where each bid object is a hash containing team and priority information.

2. Functionality
*Initial Setup: Initializes a hash priority_counts with keys 1, 2, and 3, each having an initial value of 0. These keys represent the priority levels, and their values count the number of teams assigned to each level.

*Iterating Over Topics and Teams: Iterates over each topic and its associated teams found in assigned_teams_by_topic. For each team in a topic, the method searches bids_by_topic[topic_id] to find a bid made by the team.

*Updating Priority Counts: If a bid is found, the method increments the count in priority_counts corresponding to the priority level in the bid. This process effectively tallies the number of teams assigned to each priority level.

3. Returns
*priority_counts (Hash): A hash with keys 1, 2, and 3, where each key's value represents the count of teams assigned to that respective priority level.

<pre>
# Calculates the count of assigned teams for each priority level (1, 2, 3) across all topics.
# It checks each team associated with a topic and determines if the team's bid matches
# one of the priority levels, incrementing the respective count if so.
def calculate_priority_counts(assigned_teams_by_topic, bids_by_topic)
priority_counts = { 1 => 0, 2 => 0, 3 => 0 }
assigned_teams_by_topic.each do |topic_id, teams|
teams.each do |team|
bid_info = bids_by_topic[topic_id].find { |bid| bid[:team] == team }
priority_counts[bid_info[:priority]] += 1 if bid_info
end
end
priority_counts
end
</pre>

'''method 3: calculate_percentages'''

* This method calculates the percentages of teams that received their first, second, and third choice based on the counts of teams at each priority level.

<pre>
# Calculates the percentages of teams that received their first, second, and third choice
# based on the counts of teams at each priority level.
def calculate_percentages(priority_counts, total_teams)
priority_counts.transform_values { |count| (count.to_f / total_teams * 100).round(2) }
end
</pre>

Change in <code> app/views/lottery/bidding_table_for_each_topic.html.erb </code>

[[File:bidding_percentage.png | 888px]]

<pre>
<h3>Bidding Details for <%= @assignment.name %></h3>

<div class="percentages" style="margin-bottom: 20px; padding: 15px; border: 1px solid
#ccc; border-radius: 5px; background-color: #f9f9f9;">
<h4 style="margin-bottom: 15px; border-bottom: 1px solid #eee;
padding-bottom: 10px;">Percentage of Teams Getting Their Choices:</h4>
<ul style="list-style: none; padding: 0;">
<li><strong>#1 Choice:</strong> <span style="color: #4CAF50;"><%= @percentages[1] || 0 %> %</span></li>
<li><strong>#2 Choice:</strong> <span style="color: #FF9800;"><%= @percentages[2] || 0 %> %</span></li>
<li><strong>#3 Choice:</strong> <span style="color: #F44336;"><%= @percentages[3] || 0 %> %</span></li>
</ul>
</div>

<style>
.assigned-team {
background-color: yellow;
color: black;
}
.bids-column {
width: 100px; /* Adjust width as needed */
}
</style>

<table class="table table-bordered table-hover">
<thead>
<tr>
<th>Topic Name</th>
<th>Topic ID</th>
<th>Bidding Teams</th>
<th>#1 bids</th>
<th>#2 bids</th>
<th>#3 bids</th>
</tr>
</thead>
<tbody>
<% @topics.each do |topic| %>
<tr>
<td><%= topic.topic_name %></td>
<td><%= topic.id %></td>
<td>
<% @bids_by_topic[topic.id].each do |bid_info| %>
<% team = bid_info[:team] %>
<% assigned_team = @assigned_teams_by_topic[topic.id].include?(team) %>
<span class="<%= assigned_team ? 'assigned-team' : '' %>">
<%= team.name %> (#<%= bid_info[:priority] %>)
</span>
<% end %>
</td>
<td class="bids-column">
<% if @count1[topic.id] != 0%>
<%= @count1[topic.id] %>
<%else%>
–
<%end%>
</td>
<td class="bids-column">
<% if @count2[topic.id] != 0%>
<%= @count2[topic.id] %>
<%else%>
–
<%end%>
</td>
<td class="bids-column">
<% if @count3[topic.id] != 0%>
<%= @count3[topic.id] %>
<%else%>
–
<%end%>
</td>
</tr>
<% end %>
</tbody>
</table>

<a href="javascript:history.back()">Back</a>
</pre>

== Test Plan ==

1. Test for Populating Bids and Assigned Teams:
*This test ensures that the bidding_table_for_each_topic method correctly populates bids and assigned teams for each topic.
*It checks if @bids_by_topic is populated correctly, verifying the length of bids for specific topics.
*It tests @assigned_teams_by_topic, ensuring it handles cases where topics have no teams.

2. Test for Fetching All Topics:
*This test verifies that all topics for the assignment are fetched and stored in @topics.

3. Test for Calculating Priority Counts:
*This test checks the calculation of priority counts for each topic.
*It compares the calculated priority counts against an expected set of values.

4. Test for Calculating Percentages for Teams Getting Their Choices:
*This test ensures that the method correctly calculates the percentages of teams getting their preferred choices.
*It handles special cases where the expected percentages are not a number (NaN).

Rspec Testing <code> app/views/lottery/bidding_table_for_each_topic.html.erb </code>

<pre>
describe '#bidding_table_for_each_topic' do
before :each do
# Set the assignment id in the params
params = ActionController::Parameters.new(id: assignment.id)
allow(controller).to receive(:params).and_return(params)
end
it 'populates bids and assigned teams for each topic, handling topics with no teams' do
controller.bidding_table_for_each_topic
# Check if @bids_by_topic is populated correctly
expect(controller.instance_variable_get(:@bids_by_topic)[topic1.id].length).to eq(1)
expect(controller.instance_variable_get(:@bids_by_topic)[topic2.id].length).to eq(1)
# Check if @assigned_teams_by_topic is populated correctly, allowing for no teams
assigned_teams_topic1 = controller.instance_variable_get(:@assigned_teams_by_topic)[topic1.id]
if assigned_teams_topic1
expect(assigned_teams_topic1.length).to(satisfy { |value| (value == 0) || (value == 1) })
else
expect(assigned_teams_topic1).to be_nil
end
# Check the counts of bids for each priority level
# Ensure to adjust these based on what is set up in your test data
expect(controller.instance_variable_get(:@count1)[topic1.id]).to eq(1)
# assuming there is one bid with priority 1 for topic1
expect(controller.instance_variable_get(:@count2)[topic1.id]).to eq(0)
# assuming there are no bids with priority 2 for topic1
expect(controller.instance_variable_get(:@count3)[topic1.id]).to eq(0)
# assuming there are no bids with priority 3 for topic1
end

it 'fetches all topics for the assignment' do
controller.bidding_table_for_each_topic
expect(controller.instance_variable_get(:@topics)).to match_array([topic1, topic2, topic3, topic4])
end

it 'correctly calculates priority counts for each topic' do
controller.bidding_table_for_each_topic

# Assuming you have a way to know the expected counts for each priority
expected_priority_counts = { 1 => 0,
2 => 0,
3 => 0 }

priority_counts = controller.instance_variable_get(:@priority_counts)
expect(priority_counts).to eq(expected_priority_counts)
end

it 'correctly calculates percentages for teams getting their choices' do
controller.bidding_table_for_each_topic

# Assuming you have a way to know the expected percentages
expected_percentages = { 1 => Float::NAN,
2 => Float::NAN,
3 => Float::NAN }

percentages = controller.instance_variable_get(:@percentages)
expect(percentages[1].nan?).to be true if expected_percentages[1].nan?
expect(percentages[2].nan?).to be true if expected_percentages[2].nan?
expect(percentages[3].nan?).to be true if expected_percentages[3].nan?
end
end
end
</pre>

== Relevant Links ==

'''Github Repository: ''' https://github.com/Shreshth-Malik/expertiza

== Testing Credentials ==

username: instructor6

password: password

== Team ==
'''Mentor'''

Edward F. Gehringer (efg@ncsu.edu)

'''Members'''

Richard Li (rli14@ncsu.edu)

Shreshth Malik (smalik4@ncsu.edu)

Shuai Chen (schen76@ncsu.edu)

CSC/ECE 517 Fall 2023 - E2360. View for Results of Bidding (Phase2)

2023-12-05T07:52:14Z

Schen76:

== Motivation ==

The bidding view is needed because we don’t have a way of finding out whether the bidding algorithm is running correctly. This project is to add a bidding view to show how the topics are assigned to those teams who bid.

== Work Plan ==

Based on the project's objectives and feedback received from our mentor, we have identified specific areas for improvement:

1) Refactor variable names within methods such as "bidding_details" and variables like "Topic name" and "Bidding teams" to enhance clarity and specificity.

2) Adjust capitalization for certain components, ensuring that only the first word is capitalized for consistency.

3) Introduce calculations to determine percentages based on additional data, such as the total number of teams and the number of teams for each priority, within the "lottery_controller."

4) Conduct thorough testing of the modified controller and view to ensure optimal functionality.

[[File:Newfeature.jpg | 888px]]

== Design ==

To add functionality for showing the percentages of the number of teams that got their #1, #2, and #3 choices. We can follow these high-level steps:

'''Lottery_Controller:'''

i) Calculate the Total Number of Teams: Before we can calculate percentages, we need to know the total number of teams that participated in the bidding process. This will be our denominator in the percentage calculation.

ii) Calculate the Number of Teams for Each Priority: From our `bidding_details` method, we already have counts for how many teams bid on each topic as their #1, #2, and #3 choice (`@count1`, `@count2`, `@count3`). However, these counts are currently organized by topic. We would need to modify this to count how many teams got their #1, #2, and #3 choices as their assigned topic.

iii) Calculate Percentages: Once we have the number of teams that got their #1, #2, and #3 choices, we can calculate the percentages by dividing these numbers by the total number of teams and multiplying by 100.

'''Bidding_detail view:'''

i) Update the View and Display Percentages: Above the table in our previous view, we can add a section to display these percentages.

ii) Format the Display: We will use a bold heading for each percentage type and format the number to a fixed number of decimal places.

iii) Ensure Responsiveness: Make sure the display of these percentages adjusts well to different screen sizes, maintaining readability and layout consistency.

== Code Effort ==

Change in <code> app/controllers/lottery_controller.rb </code>

'''method 1: bidding_table_for_each_topic'''

This method generates a bidding table for each topic within an assignment. It performs several operations to gather and organize data related to topics, bids, and teams. Here's a breakdown of what the code does:

1. Fetch Assignment:

*It retrieves the assignment with the specified params[:id] from the database and stores it in the @assignment instance variable.

2. Fetch Topics:

*It retrieves all sign-up topics associated with the assignment and stores them in the @topics instance variable.

3. Fetch Bids and Assigned Teams:

For each topic in @topics, it:
*Retrieves all bids associated with that topic and stores them in a hash, where the key is the topic's ID and the value is an array of bids with their associated teams and priorities.
*Retrieves teams that are not waitlisted for the topic and stores them in a hash, again using the topic's ID as the key and an array of teams as the value.

4. Priority Count Calculation:

*It dynamically calculates and updates the counts for each bid priority level (1, 2, and 3) for each topic. These counts are stored in instance variables named @count1, @count2, and @count3. These instance variables are hashes where the keys are topic IDs, and the values are counts for each priority level.

5. Calculate Total Teams:

*It determines the total number of teams across all topics in the assignment by counting distinct team IDs among all non-waitlisted teams for the specified topics.

6. Calculate Priority Counts and Percentages:

*It calls two helper methods, calculate_priority_counts and calculate_percentages, to calculate the total counts of teams at each priority level and the corresponding percentages. The results are stored in the @priority_counts and @percentages instance variables, respectively.

<pre>
# Prepares data for displaying the bidding details for each topic within an assignment.
# It calculates the number of bids for each priority (1, 2, 3) per topic and also computes
# the overall percentages of teams that received their first, second, and third choice.
def bidding_table_for_each_topic
@assignment = Assignment.find(params[:id])
# Fetch all topics for the assignment
@topics = @assignment.sign_up_topics
# Fetch all bids for these topics
@bids_by_topic = {}
@assigned_teams_by_topic = {} # This will store the assigned teams for each topic
@topics.each do |topic|
# Assuming bids are stored with a topic_id, and each bid has a team associated with it
@bids_by_topic[topic.id] = Bid.where(topic_id: topic.id).map { |bid| { team: bid.team, priority: bid.priority } }
# Fetch teams that are not waitlisted for this topic
@assigned_teams_by_topic[topic.id] = SignedUpTeam.where(topic_id: topic.id, is_waitlisted: false).map(&:team)
# @count1[topic.id] += @bids_by_topic[topic.id].count { |bid| bid[:priority] == 1 }
# @count2[topic.id] += @bids_by_topic[topic.id].count { |bid| bid[:priority] == 2 }
# @count3[topic.id] += @bids_by_topic[topic.id].count { |bid| bid[:priority] == 3 }

# Dynamically initializing and updating @count1, @count2, and @count3
(1..3).each do |priority|
instance_variable_set("@count#{priority}", Hash.new(0)) unless instance_variable_defined?("@count#{priority}")
instance_variable_get("@count#{priority}")[topic.id] = @bids_by_topic[topic.id].count { |bid| bid[:priority] == priority }
end
end
# Calculate the total number of teams and percentages after fetching bid details
topic_ids = SignUpTopic.where(assignment_id: @assignment.id).pluck(:id)
@total_teams = SignedUpTeam.where(topic_id: topic_ids).distinct.count(:team_id)
@priority_counts = calculate_priority_counts(@assigned_teams_by_topic, @bids_by_topic)
@percentages = calculate_percentages(@priority_counts, @total_teams)

end
</pre>

'''method 2: calculate_priority_counts'''

1. Parameters
*assigned_teams_by_topic (Hash): A hash mapping each topic to an array of assigned teams.
*bids_by_topic (Hash): A hash mapping each topic to an array of bid objects, where each bid object is a hash containing team and priority information.

2. Functionality
*Initial Setup: Initializes a hash priority_counts with keys 1, 2, and 3, each having an initial value of 0. These keys represent the priority levels, and their values count the number of teams assigned to each level.

*Iterating Over Topics and Teams: Iterates over each topic and its associated teams found in assigned_teams_by_topic. For each team in a topic, the method searches bids_by_topic[topic_id] to find a bid made by the team.

*Updating Priority Counts: If a bid is found, the method increments the count in priority_counts corresponding to the priority level in the bid. This process effectively tallies the number of teams assigned to each priority level.

3. Returns
*priority_counts (Hash): A hash with keys 1, 2, and 3, where each key's value represents the count of teams assigned to that respective priority level.

<pre>
# Calculates the count of assigned teams for each priority level (1, 2, 3) across all topics.
# It checks each team associated with a topic and determines if the team's bid matches
# one of the priority levels, incrementing the respective count if so.
def calculate_priority_counts(assigned_teams_by_topic, bids_by_topic)
priority_counts = { 1 => 0, 2 => 0, 3 => 0 }
assigned_teams_by_topic.each do |topic_id, teams|
teams.each do |team|
bid_info = bids_by_topic[topic_id].find { |bid| bid[:team] == team }
priority_counts[bid_info[:priority]] += 1 if bid_info
end
end
priority_counts
end
</pre>

'''method 3: calculate_percentages'''

* This method calculates the percentages of teams that received their first, second, and third choice based on the counts of teams at each priority level.

<pre>
# Calculates the percentages of teams that received their first, second, and third choice
# based on the counts of teams at each priority level.
def calculate_percentages(priority_counts, total_teams)
priority_counts.transform_values { |count| (count.to_f / total_teams * 100).round(2) }
end
</pre>

Change in <code> app/views/lottery/bidding_table_for_each_topic.html.erb </code>

[[File:bidding_percentage.png | 888px]]

<pre>
<h3>Bidding Details for <%= @assignment.name %></h3>

<div class="percentages" style="margin-bottom: 20px; padding: 15px; border: 1px solid
#ccc; border-radius: 5px; background-color: #f9f9f9;">
<h4 style="margin-bottom: 15px; border-bottom: 1px solid #eee;
padding-bottom: 10px;">Percentage of Teams Getting Their Choices:</h4>
<ul style="list-style: none; padding: 0;">
<li><strong>#1 Choice:</strong> <span style="color: #4CAF50;"><%= @percentages[1] || 0 %> %</span></li>
<li><strong>#2 Choice:</strong> <span style="color: #FF9800;"><%= @percentages[2] || 0 %> %</span></li>
<li><strong>#3 Choice:</strong> <span style="color: #F44336;"><%= @percentages[3] || 0 %> %</span></li>
</ul>
</div>

<style>
.assigned-team {
background-color: yellow;
color: black;
}
.bids-column {
width: 100px; /* Adjust width as needed */
}
</style>

<table class="table table-bordered table-hover">
<thead>
<tr>
<th>Topic Name</th>
<th>Topic ID</th>
<th>Bidding Teams</th>
<th>#1 bids</th>
<th>#2 bids</th>
<th>#3 bids</th>
</tr>
</thead>
<tbody>
<% @topics.each do |topic| %>
<tr>
<td><%= topic.topic_name %></td>
<td><%= topic.id %></td>
<td>
<% @bids_by_topic[topic.id].each do |bid_info| %>
<% team = bid_info[:team] %>
<% assigned_team = @assigned_teams_by_topic[topic.id].include?(team) %>
<span class="<%= assigned_team ? 'assigned-team' : '' %>">
<%= team.name %> (#<%= bid_info[:priority] %>)
</span>
<% end %>
</td>
<td class="bids-column">
<% if @count1[topic.id] != 0%>
<%= @count1[topic.id] %>
<%else%>
–
<%end%>
</td>
<td class="bids-column">
<% if @count2[topic.id] != 0%>
<%= @count2[topic.id] %>
<%else%>
–
<%end%>
</td>
<td class="bids-column">
<% if @count3[topic.id] != 0%>
<%= @count3[topic.id] %>
<%else%>
–
<%end%>
</td>
</tr>
<% end %>
</tbody>
</table>

<a href="javascript:history.back()">Back</a>
</pre>

== Test Plan ==

1. Test for Populating Bids and Assigned Teams:
*This test ensures that the bidding_table_for_each_topic method correctly populates bids and assigned teams for each topic.
*It checks if @bids_by_topic is populated correctly, verifying the length of bids for specific topics.
*It tests @assigned_teams_by_topic, ensuring it handles cases where topics have no teams.

2. Test for Fetching All Topics:
*This test verifies that all topics for the assignment are fetched and stored in @topics.

3. Test for Calculating Priority Counts:
*This test checks the calculation of priority counts for each topic.
*It compares the calculated priority counts against an expected set of values.

4. Test for Calculating Percentages for Teams Getting Their Choices:
*This test ensures that the method correctly calculates the percentages of teams getting their preferred choices.
*It handles special cases where the expected percentages are not a number (NaN).

Rspec Testing <code> app/views/lottery/bidding_table_for_each_topic.html.erb </code>

<pre>
describe '#bidding_table_for_each_topic' do
before :each do
# Set the assignment id in the params
params = ActionController::Parameters.new(id: assignment.id)
allow(controller).to receive(:params).and_return(params)
end
it 'populates bids and assigned teams for each topic, handling topics with no teams' do
controller.bidding_table_for_each_topic
# Check if @bids_by_topic is populated correctly
expect(controller.instance_variable_get(:@bids_by_topic)[topic1.id].length).to eq(1)
expect(controller.instance_variable_get(:@bids_by_topic)[topic2.id].length).to eq(1)
# Check if @assigned_teams_by_topic is populated correctly, allowing for no teams
assigned_teams_topic1 = controller.instance_variable_get(:@assigned_teams_by_topic)[topic1.id]
if assigned_teams_topic1
expect(assigned_teams_topic1.length).to(satisfy { |value| (value == 0) || (value == 1) })
else
expect(assigned_teams_topic1).to be_nil
end
# Check the counts of bids for each priority level
# Ensure to adjust these based on what is set up in your test data
expect(controller.instance_variable_get(:@count1)[topic1.id]).to eq(1)
# assuming there is one bid with priority 1 for topic1
expect(controller.instance_variable_get(:@count2)[topic1.id]).to eq(0)
# assuming there are no bids with priority 2 for topic1
expect(controller.instance_variable_get(:@count3)[topic1.id]).to eq(0)
# assuming there are no bids with priority 3 for topic1
end

it 'fetches all topics for the assignment' do
controller.bidding_table_for_each_topic
expect(controller.instance_variable_get(:@topics)).to match_array([topic1, topic2, topic3, topic4])
end

it 'correctly calculates priority counts for each topic' do
controller.bidding_table_for_each_topic

# Assuming you have a way to know the expected counts for each priority
expected_priority_counts = { 1 => 0,
2 => 0,
3 => 0 }

priority_counts = controller.instance_variable_get(:@priority_counts)
expect(priority_counts).to eq(expected_priority_counts)
end

it 'correctly calculates percentages for teams getting their choices' do
controller.bidding_table_for_each_topic

# Assuming you have a way to know the expected percentages
expected_percentages = { 1 => Float::NAN,
2 => Float::NAN,
3 => Float::NAN }

percentages = controller.instance_variable_get(:@percentages)
expect(percentages[1].nan?).to be true if expected_percentages[1].nan?
expect(percentages[2].nan?).to be true if expected_percentages[2].nan?
expect(percentages[3].nan?).to be true if expected_percentages[3].nan?
end
end
end
</pre>

== Relevant Links ==

'''Github Repository: ''' https://github.com/Shreshth-Malik/expertiza

== Testing Credentials ==

username: instructor6

password: password

== Team ==
'''Mentor'''

Edward F. Gehringer (efg@ncsu.edu)

'''Members'''

Richard Li (rli14@ncsu.edu)

Shreshth Malik (smalik4@ncsu.edu)

Shuai Chen (schen76@ncsu.edu)

CSC/ECE 517 Fall 2023 - E2360. View for Results of Bidding (Phase2)

2023-12-05T07:40:03Z

Schen76: /* Team */

== Motivation ==

The bidding view is needed because we don’t have a way of finding out whether the bidding algorithm is running correctly. This project is to add a bidding view to show how the topics are assigned to those teams who bid.

== Work Plan ==

Based on the project's objectives and feedback received from our mentor, we have identified specific areas for improvement:

1) Refactor variable names within methods such as "bidding_details" and variables like "Topic name" and "Bidding teams" to enhance clarity and specificity.

2) Adjust capitalization for certain components, ensuring that only the first word is capitalized for consistency.

3) Introduce calculations to determine percentages based on additional data, such as the total number of teams and the number of teams for each priority, within the "lottery_controller."

4) Conduct thorough testing of the modified controller and view to ensure optimal functionality.

[[File:Newfeature.jpg | 888px]]

== Design ==

To add functionality for showing the percentages of the number of teams that got their #1, #2, and #3 choices. We can follow these high-level steps:

'''Lottery_Controller:'''

i) Calculate the Total Number of Teams: Before we can calculate percentages, we need to know the total number of teams that participated in the bidding process. This will be our denominator in the percentage calculation.

ii) Calculate the Number of Teams for Each Priority: From our `bidding_details` method, we already have counts for how many teams bid on each topic as their #1, #2, and #3 choice (`@count1`, `@count2`, `@count3`). However, these counts are currently organized by topic. We would need to modify this to count how many teams got their #1, #2, and #3 choices as their assigned topic.

iii) Calculate Percentages: Once we have the number of teams that got their #1, #2, and #3 choices, we can calculate the percentages by dividing these numbers by the total number of teams and multiplying by 100.

'''Bidding_detail view:'''

i) Update the View and Display Percentages: Above the table in our previous view, we can add a section to display these percentages.

ii) Format the Display: We will use a bold heading for each percentage type and format the number to a fixed number of decimal places.

iii) Ensure Responsiveness: Make sure the display of these percentages adjusts well to different screen sizes, maintaining readability and layout consistency.

== Code Effort ==

Change in <code> app/controllers/lottery_controller.rb </code>

'''method 1: bidding_table_for_each_topic'''

This method generates a bidding table for each topic within an assignment. It performs several operations to gather and organize data related to topics, bids, and teams. Here's a breakdown of what the code does:

1. Fetch Assignment:

*It retrieves the assignment with the specified params[:id] from the database and stores it in the @assignment instance variable.

2. Fetch Topics:

*It retrieves all sign-up topics associated with the assignment and stores them in the @topics instance variable.

3. Fetch Bids and Assigned Teams:

For each topic in @topics, it:
*Retrieves all bids associated with that topic and stores them in a hash, where the key is the topic's ID and the value is an array of bids with their associated teams and priorities.
*Retrieves teams that are not waitlisted for the topic and stores them in a hash, again using the topic's ID as the key and an array of teams as the value.

4. Priority Count Calculation:

*It dynamically calculates and updates the counts for each bid priority level (1, 2, and 3) for each topic. These counts are stored in instance variables named @count1, @count2, and @count3. These instance variables are hashes where the keys are topic IDs, and the values are counts for each priority level.

5. Calculate Total Teams:

*It determines the total number of teams across all topics in the assignment by counting distinct team IDs among all non-waitlisted teams for the specified topics.

6. Calculate Priority Counts and Percentages:

*It calls two helper methods, calculate_priority_counts and calculate_percentages, to calculate the total counts of teams at each priority level and the corresponding percentages. The results are stored in the @priority_counts and @percentages instance variables, respectively.

<pre>
# Prepares data for displaying the bidding details for each topic within an assignment.
# It calculates the number of bids for each priority (1, 2, 3) per topic and also computes
# the overall percentages of teams that received their first, second, and third choice.
def bidding_table_for_each_topic
@assignment = Assignment.find(params[:id])
# Fetch all topics for the assignment
@topics = @assignment.sign_up_topics
# Fetch all bids for these topics
@bids_by_topic = {}
@assigned_teams_by_topic = {} # This will store the assigned teams for each topic
@topics.each do |topic|
# Assuming bids are stored with a topic_id, and each bid has a team associated with it
@bids_by_topic[topic.id] = Bid.where(topic_id: topic.id).map { |bid| { team: bid.team, priority: bid.priority } }
# Fetch teams that are not waitlisted for this topic
@assigned_teams_by_topic[topic.id] = SignedUpTeam.where(topic_id: topic.id, is_waitlisted: false).map(&:team)
# @count1[topic.id] += @bids_by_topic[topic.id].count { |bid| bid[:priority] == 1 }
# @count2[topic.id] += @bids_by_topic[topic.id].count { |bid| bid[:priority] == 2 }
# @count3[topic.id] += @bids_by_topic[topic.id].count { |bid| bid[:priority] == 3 }

# Dynamically initializing and updating @count1, @count2, and @count3
(1..3).each do |priority|
instance_variable_set("@count#{priority}", Hash.new(0)) unless instance_variable_defined?("@count#{priority}")
instance_variable_get("@count#{priority}")[topic.id] = @bids_by_topic[topic.id].count { |bid| bid[:priority] == priority }
end
end
# Calculate the total number of teams and percentages after fetching bid details
topic_ids = SignUpTopic.where(assignment_id: @assignment.id).pluck(:id)
@total_teams = SignedUpTeam.where(topic_id: topic_ids).distinct.count(:team_id)
@priority_counts = calculate_priority_counts(@assigned_teams_by_topic, @bids_by_topic)
@percentages = calculate_percentages(@priority_counts, @total_teams)

end
</pre>

'''method 2: calculate_priority_counts'''

1. Parameters
*assigned_teams_by_topic (Hash): A hash mapping each topic to an array of assigned teams.
*bids_by_topic (Hash): A hash mapping each topic to an array of bid objects, where each bid object is a hash containing team and priority information.

2. Functionality
*Initial Setup: Initializes a hash priority_counts with keys 1, 2, and 3, each having an initial value of 0. These keys represent the priority levels, and their values count the number of teams assigned to each level.

*Iterating Over Topics and Teams: Iterates over each topic and its associated teams found in assigned_teams_by_topic. For each team in a topic, the method searches bids_by_topic[topic_id] to find a bid made by the team.

*Updating Priority Counts: If a bid is found, the method increments the count in priority_counts corresponding to the priority level in the bid. This process effectively tallies the number of teams assigned to each priority level.

3. Returns
*priority_counts (Hash): A hash with keys 1, 2, and 3, where each key's value represents the count of teams assigned to that respective priority level.

<pre>
# Calculates the count of assigned teams for each priority level (1, 2, 3) across all topics.
# It checks each team associated with a topic and determines if the team's bid matches
# one of the priority levels, incrementing the respective count if so.
def calculate_priority_counts(assigned_teams_by_topic, bids_by_topic)
priority_counts = { 1 => 0, 2 => 0, 3 => 0 }
assigned_teams_by_topic.each do |topic_id, teams|
teams.each do |team|
bid_info = bids_by_topic[topic_id].find { |bid| bid[:team] == team }
priority_counts[bid_info[:priority]] += 1 if bid_info
end
end
priority_counts
end
</pre>

'''method 3: calculate_percentages'''

* This method calculates the percentages of teams that received their first, second, and third choice based on the counts of teams at each priority level.

<pre>
# Calculates the percentages of teams that received their first, second, and third choice
# based on the counts of teams at each priority level.
def calculate_percentages(priority_counts, total_teams)
priority_counts.transform_values { |count| (count.to_f / total_teams * 100).round(2) }
end
</pre>

Change in <code> app/views/lottery/bidding_table_for_each_topic.html.erb </code>

[[File:bidding_percentage.png | 888px]]

<pre>
<h3>Bidding Details for <%= @assignment.name %></h3>

<div class="percentages" style="margin-bottom: 20px; padding: 15px; border: 1px solid #ccc; border-radius: 5px; background-color: #f9f9f9;">
<h4 style="margin-bottom: 15px; border-bottom: 1px solid #eee; padding-bottom: 10px;">Percentage of Teams Getting Their Choices:</h4>
<ul style="list-style: none; padding: 0;">
<li><strong>#1 Choice:</strong> <span style="color: #4CAF50;"><%= @percentages[1] || 0 %> %</span></li>
<li><strong>#2 Choice:</strong> <span style="color: #FF9800;"><%= @percentages[2] || 0 %> %</span></li>
<li><strong>#3 Choice:</strong> <span style="color: #F44336;"><%= @percentages[3] || 0 %> %</span></li>
</ul>
</div>

<style>
.assigned-team {
background-color: yellow;
color: black;
}
.bids-column {
width: 100px; /* Adjust width as needed */
}
</style>

<table class="table table-bordered table-hover">
<thead>
<tr>
<th>Topic Name</th>
<th>Topic ID</th>
<th>Bidding Teams</th>
<th>#1 bids</th>
<th>#2 bids</th>
<th>#3 bids</th>
</tr>
</thead>
<tbody>
<% @topics.each do |topic| %>
<tr>
<td><%= topic.topic_name %></td>
<td><%= topic.id %></td>
<td>
<% @bids_by_topic[topic.id].each do |bid_info| %>
<% team = bid_info[:team] %>
<% assigned_team = @assigned_teams_by_topic[topic.id].include?(team) %>
<span class="<%= assigned_team ? 'assigned-team' : '' %>">
<%= team.name %> (#<%= bid_info[:priority] %>)
</span>
<% end %>
</td>
<td class="bids-column">
<% if @count1[topic.id] != 0%>
<%= @count1[topic.id] %>
<%else%>
–
<%end%>
</td>
<td class="bids-column">
<% if @count2[topic.id] != 0%>
<%= @count2[topic.id] %>
<%else%>
–
<%end%>
</td>
<td class="bids-column">
<% if @count3[topic.id] != 0%>
<%= @count3[topic.id] %>
<%else%>
–
<%end%>
</td>
</tr>
<% end %>
</tbody>
</table>

<a href="javascript:history.back()">Back</a>
</pre>

== Test Plan ==

Added Rspec Testing <code> app/views/lottery/bidding_table_for_each_topic.html.erb </code>

<pre>
describe '#bidding_table_for_each_topic' do
before :each do
# Set the assignment id in the params
params = ActionController::Parameters.new(id: assignment.id)
allow(controller).to receive(:params).and_return(params)
end
it 'populates bids and assigned teams for each topic, handling topics with no teams' do
controller.bidding_table_for_each_topic
# Check if @bids_by_topic is populated correctly
expect(controller.instance_variable_get(:@bids_by_topic)[topic1.id].length).to eq(1)
expect(controller.instance_variable_get(:@bids_by_topic)[topic2.id].length).to eq(1)
# Check if @assigned_teams_by_topic is populated correctly, allowing for no teams
assigned_teams_topic1 = controller.instance_variable_get(:@assigned_teams_by_topic)[topic1.id]
if assigned_teams_topic1
expect(assigned_teams_topic1.length).to(satisfy { |value| (value == 0) || (value == 1) })
else
expect(assigned_teams_topic1).to be_nil
end
# Check the counts of bids for each priority level
# Ensure to adjust these based on what is set up in your test data
expect(controller.instance_variable_get(:@count1)[topic1.id]).to eq(1)
# assuming there is one bid with priority 1 for topic1
expect(controller.instance_variable_get(:@count2)[topic1.id]).to eq(0)
# assuming there are no bids with priority 2 for topic1
expect(controller.instance_variable_get(:@count3)[topic1.id]).to eq(0)
# assuming there are no bids with priority 3 for topic1
end

it 'fetches all topics for the assignment' do
controller.bidding_table_for_each_topic
expect(controller.instance_variable_get(:@topics)).to match_array([topic1, topic2, topic3, topic4])
end

it 'correctly calculates priority counts for each topic' do
controller.bidding_table_for_each_topic

# Assuming you have a way to know the expected counts for each priority
expected_priority_counts = { 1 => 0,
2 => 0,
3 => 0 }

priority_counts = controller.instance_variable_get(:@priority_counts)
expect(priority_counts).to eq(expected_priority_counts)
end

it 'correctly calculates percentages for teams getting their choices' do
controller.bidding_table_for_each_topic

# Assuming you have a way to know the expected percentages
expected_percentages = { 1 => Float::NAN,
2 => Float::NAN,
3 => Float::NAN }

percentages = controller.instance_variable_get(:@percentages)
expect(percentages[1].nan?).to be true if expected_percentages[1].nan?
expect(percentages[2].nan?).to be true if expected_percentages[2].nan?
expect(percentages[3].nan?).to be true if expected_percentages[3].nan?
end
end
end
</pre>

According to the given test skeleton and the features we've implemented and to be implemented. Here are the testing ideas:

'''Context 1: When There Are No Bids or Assigned Teams'''

Test 1: Check if we get empty arrays for bids and assigned teams after running the "bidding_details" method.

Test 2: Check if the percentage of teams getting their #1, #2, and #3 choices are all 0.

'''Context 2: When There Are Bids and Assigned Teams for the Assignment'''

Test 3: We would first set up a known distribution of bids across different priority levels. After executing the "bidding_details" method, the test verifies that the returned count of bids for each priority level matches the expected distribution set up in the test environment.

Test 4: Ensure that the method correctly identifies and returns the assigned teams for each topic. In this test, the setup would include an assignment with pre-assigned teams to various topics. The "bidding_details" method is then called, and the test checks whether the method accurately returns the list of assigned teams for each topic, as per the test setup.

Test 5: Check if all teams bidding on a different topic, they all get the topic they want, and the percentage of #1 is 100%, while #2 and #3 are 0s.

Test 6: Check if all teams bidding on the same topic, only one team gets the topic they want, and the percentage of #1 is (1/teams)%, while #2 and #3 are 0s.

Test 7: Check if a team is a first/second/third team to bid on some topic, that topic is finally assigned to this team. In this case, #1, #2, or #3 is a non-zero value.

Test 8: Provide mocking data and we pre-calculate the percentage value of #1, #2 and #3, check if the calculated values are the same as ours.

== Relevant Links ==

'''Github Repository: ''' https://github.com/Shreshth-Malik/expertiza

== Team ==
'''Mentor'''

Edward F. Gehringer (efg@ncsu.edu)

'''Members'''

Richard Li (rli14@ncsu.edu)

Shreshth Malik (smalik4@ncsu.edu)

Shuai Chen (schen76@ncsu.edu)

CSC/ECE 517 Fall 2023 - E2360. View for Results of Bidding (Phase2)

2023-12-05T07:36:00Z

Schen76:

== Motivation ==

The bidding view is needed because we don’t have a way of finding out whether the bidding algorithm is running correctly. This project is to add a bidding view to show how the topics are assigned to those teams who bid.

== Work Plan ==

Based on the project's objectives and feedback received from our mentor, we have identified specific areas for improvement:

1) Refactor variable names within methods such as "bidding_details" and variables like "Topic name" and "Bidding teams" to enhance clarity and specificity.

2) Adjust capitalization for certain components, ensuring that only the first word is capitalized for consistency.

3) Introduce calculations to determine percentages based on additional data, such as the total number of teams and the number of teams for each priority, within the "lottery_controller."

4) Conduct thorough testing of the modified controller and view to ensure optimal functionality.

[[File:Newfeature.jpg | 888px]]

== Design ==

To add functionality for showing the percentages of the number of teams that got their #1, #2, and #3 choices. We can follow these high-level steps:

'''Lottery_Controller:'''

i) Calculate the Total Number of Teams: Before we can calculate percentages, we need to know the total number of teams that participated in the bidding process. This will be our denominator in the percentage calculation.

ii) Calculate the Number of Teams for Each Priority: From our `bidding_details` method, we already have counts for how many teams bid on each topic as their #1, #2, and #3 choice (`@count1`, `@count2`, `@count3`). However, these counts are currently organized by topic. We would need to modify this to count how many teams got their #1, #2, and #3 choices as their assigned topic.

iii) Calculate Percentages: Once we have the number of teams that got their #1, #2, and #3 choices, we can calculate the percentages by dividing these numbers by the total number of teams and multiplying by 100.

'''Bidding_detail view:'''

i) Update the View and Display Percentages: Above the table in our previous view, we can add a section to display these percentages.

ii) Format the Display: We will use a bold heading for each percentage type and format the number to a fixed number of decimal places.

iii) Ensure Responsiveness: Make sure the display of these percentages adjusts well to different screen sizes, maintaining readability and layout consistency.

== Code Effort ==

Change in <code> app/controllers/lottery_controller.rb </code>

'''method 1: bidding_table_for_each_topic'''

This method generates a bidding table for each topic within an assignment. It performs several operations to gather and organize data related to topics, bids, and teams. Here's a breakdown of what the code does:

1. Fetch Assignment:

*It retrieves the assignment with the specified params[:id] from the database and stores it in the @assignment instance variable.

2. Fetch Topics:

*It retrieves all sign-up topics associated with the assignment and stores them in the @topics instance variable.

3. Fetch Bids and Assigned Teams:

For each topic in @topics, it:
*Retrieves all bids associated with that topic and stores them in a hash, where the key is the topic's ID and the value is an array of bids with their associated teams and priorities.
*Retrieves teams that are not waitlisted for the topic and stores them in a hash, again using the topic's ID as the key and an array of teams as the value.

4. Priority Count Calculation:

*It dynamically calculates and updates the counts for each bid priority level (1, 2, and 3) for each topic. These counts are stored in instance variables named @count1, @count2, and @count3. These instance variables are hashes where the keys are topic IDs, and the values are counts for each priority level.

5. Calculate Total Teams:

*It determines the total number of teams across all topics in the assignment by counting distinct team IDs among all non-waitlisted teams for the specified topics.

6. Calculate Priority Counts and Percentages:

*It calls two helper methods, calculate_priority_counts and calculate_percentages, to calculate the total counts of teams at each priority level and the corresponding percentages. The results are stored in the @priority_counts and @percentages instance variables, respectively.

<pre>
# Prepares data for displaying the bidding details for each topic within an assignment.
# It calculates the number of bids for each priority (1, 2, 3) per topic and also computes
# the overall percentages of teams that received their first, second, and third choice.
def bidding_table_for_each_topic
@assignment = Assignment.find(params[:id])
# Fetch all topics for the assignment
@topics = @assignment.sign_up_topics
# Fetch all bids for these topics
@bids_by_topic = {}
@assigned_teams_by_topic = {} # This will store the assigned teams for each topic
@topics.each do |topic|
# Assuming bids are stored with a topic_id, and each bid has a team associated with it
@bids_by_topic[topic.id] = Bid.where(topic_id: topic.id).map { |bid| { team: bid.team, priority: bid.priority } }
# Fetch teams that are not waitlisted for this topic
@assigned_teams_by_topic[topic.id] = SignedUpTeam.where(topic_id: topic.id, is_waitlisted: false).map(&:team)
# @count1[topic.id] += @bids_by_topic[topic.id].count { |bid| bid[:priority] == 1 }
# @count2[topic.id] += @bids_by_topic[topic.id].count { |bid| bid[:priority] == 2 }
# @count3[topic.id] += @bids_by_topic[topic.id].count { |bid| bid[:priority] == 3 }

# Dynamically initializing and updating @count1, @count2, and @count3
(1..3).each do |priority|
instance_variable_set("@count#{priority}", Hash.new(0)) unless instance_variable_defined?("@count#{priority}")
instance_variable_get("@count#{priority}")[topic.id] = @bids_by_topic[topic.id].count { |bid| bid[:priority] == priority }
end
end
# Calculate the total number of teams and percentages after fetching bid details
topic_ids = SignUpTopic.where(assignment_id: @assignment.id).pluck(:id)
@total_teams = SignedUpTeam.where(topic_id: topic_ids).distinct.count(:team_id)
@priority_counts = calculate_priority_counts(@assigned_teams_by_topic, @bids_by_topic)
@percentages = calculate_percentages(@priority_counts, @total_teams)

end
</pre>

'''method 2: calculate_priority_counts'''

1. Parameters
*assigned_teams_by_topic (Hash): A hash mapping each topic to an array of assigned teams.
*bids_by_topic (Hash): A hash mapping each topic to an array of bid objects, where each bid object is a hash containing team and priority information.

2. Functionality
*Initial Setup: Initializes a hash priority_counts with keys 1, 2, and 3, each having an initial value of 0. These keys represent the priority levels, and their values count the number of teams assigned to each level.

*Iterating Over Topics and Teams: Iterates over each topic and its associated teams found in assigned_teams_by_topic. For each team in a topic, the method searches bids_by_topic[topic_id] to find a bid made by the team.

*Updating Priority Counts: If a bid is found, the method increments the count in priority_counts corresponding to the priority level in the bid. This process effectively tallies the number of teams assigned to each priority level.

3. Returns
*priority_counts (Hash): A hash with keys 1, 2, and 3, where each key's value represents the count of teams assigned to that respective priority level.

<pre>
# Calculates the count of assigned teams for each priority level (1, 2, 3) across all topics.
# It checks each team associated with a topic and determines if the team's bid matches
# one of the priority levels, incrementing the respective count if so.
def calculate_priority_counts(assigned_teams_by_topic, bids_by_topic)
priority_counts = { 1 => 0, 2 => 0, 3 => 0 }
assigned_teams_by_topic.each do |topic_id, teams|
teams.each do |team|
bid_info = bids_by_topic[topic_id].find { |bid| bid[:team] == team }
priority_counts[bid_info[:priority]] += 1 if bid_info
end
end
priority_counts
end
</pre>

'''method 3: calculate_percentages'''

* This method calculates the percentages of teams that received their first, second, and third choice based on the counts of teams at each priority level.

<pre>
# Calculates the percentages of teams that received their first, second, and third choice
# based on the counts of teams at each priority level.
def calculate_percentages(priority_counts, total_teams)
priority_counts.transform_values { |count| (count.to_f / total_teams * 100).round(2) }
end
</pre>

Change in <code> app/views/lottery/bidding_table_for_each_topic.html.erb </code>

[[File:bidding_percentage.png | 888px]]

<pre>
<h3>Bidding Details for <%= @assignment.name %></h3>

<div class="percentages" style="margin-bottom: 20px; padding: 15px; border: 1px solid #ccc; border-radius: 5px; background-color: #f9f9f9;">
<h4 style="margin-bottom: 15px; border-bottom: 1px solid #eee; padding-bottom: 10px;">Percentage of Teams Getting Their Choices:</h4>
<ul style="list-style: none; padding: 0;">
<li><strong>#1 Choice:</strong> <span style="color: #4CAF50;"><%= @percentages[1] || 0 %> %</span></li>
<li><strong>#2 Choice:</strong> <span style="color: #FF9800;"><%= @percentages[2] || 0 %> %</span></li>
<li><strong>#3 Choice:</strong> <span style="color: #F44336;"><%= @percentages[3] || 0 %> %</span></li>
</ul>
</div>

<style>
.assigned-team {
background-color: yellow;
color: black;
}
.bids-column {
width: 100px; /* Adjust width as needed */
}
</style>

<table class="table table-bordered table-hover">
<thead>
<tr>
<th>Topic Name</th>
<th>Topic ID</th>
<th>Bidding Teams</th>
<th>#1 bids</th>
<th>#2 bids</th>
<th>#3 bids</th>
</tr>
</thead>
<tbody>
<% @topics.each do |topic| %>
<tr>
<td><%= topic.topic_name %></td>
<td><%= topic.id %></td>
<td>
<% @bids_by_topic[topic.id].each do |bid_info| %>
<% team = bid_info[:team] %>
<% assigned_team = @assigned_teams_by_topic[topic.id].include?(team) %>
<span class="<%= assigned_team ? 'assigned-team' : '' %>">
<%= team.name %> (#<%= bid_info[:priority] %>)
</span>
<% end %>
</td>
<td class="bids-column">
<% if @count1[topic.id] != 0%>
<%= @count1[topic.id] %>
<%else%>
–
<%end%>
</td>
<td class="bids-column">
<% if @count2[topic.id] != 0%>
<%= @count2[topic.id] %>
<%else%>
–
<%end%>
</td>
<td class="bids-column">
<% if @count3[topic.id] != 0%>
<%= @count3[topic.id] %>
<%else%>
–
<%end%>
</td>
</tr>
<% end %>
</tbody>
</table>

<a href="javascript:history.back()">Back</a>
</pre>

== Test Plan ==

Added Rspec Testing <code> app/views/lottery/bidding_table_for_each_topic.html.erb </code>

<pre>
describe '#bidding_table_for_each_topic' do
before :each do
# Set the assignment id in the params
params = ActionController::Parameters.new(id: assignment.id)
allow(controller).to receive(:params).and_return(params)
end
it 'populates bids and assigned teams for each topic, handling topics with no teams' do
controller.bidding_table_for_each_topic
# Check if @bids_by_topic is populated correctly
expect(controller.instance_variable_get(:@bids_by_topic)[topic1.id].length).to eq(1)
expect(controller.instance_variable_get(:@bids_by_topic)[topic2.id].length).to eq(1)
# Check if @assigned_teams_by_topic is populated correctly, allowing for no teams
assigned_teams_topic1 = controller.instance_variable_get(:@assigned_teams_by_topic)[topic1.id]
if assigned_teams_topic1
expect(assigned_teams_topic1.length).to(satisfy { |value| (value == 0) || (value == 1) })
else
expect(assigned_teams_topic1).to be_nil
end
# Check the counts of bids for each priority level
# Ensure to adjust these based on what is set up in your test data
expect(controller.instance_variable_get(:@count1)[topic1.id]).to eq(1)
# assuming there is one bid with priority 1 for topic1
expect(controller.instance_variable_get(:@count2)[topic1.id]).to eq(0)
# assuming there are no bids with priority 2 for topic1
expect(controller.instance_variable_get(:@count3)[topic1.id]).to eq(0)
# assuming there are no bids with priority 3 for topic1
end

it 'fetches all topics for the assignment' do
controller.bidding_table_for_each_topic
expect(controller.instance_variable_get(:@topics)).to match_array([topic1, topic2, topic3, topic4])
end

it 'correctly calculates priority counts for each topic' do
controller.bidding_table_for_each_topic

# Assuming you have a way to know the expected counts for each priority
expected_priority_counts = { 1 => 0,
2 => 0,
3 => 0 }

priority_counts = controller.instance_variable_get(:@priority_counts)
expect(priority_counts).to eq(expected_priority_counts)
end

it 'correctly calculates percentages for teams getting their choices' do
controller.bidding_table_for_each_topic

# Assuming you have a way to know the expected percentages
expected_percentages = { 1 => Float::NAN,
2 => Float::NAN,
3 => Float::NAN }

percentages = controller.instance_variable_get(:@percentages)
expect(percentages[1].nan?).to be true if expected_percentages[1].nan?
expect(percentages[2].nan?).to be true if expected_percentages[2].nan?
expect(percentages[3].nan?).to be true if expected_percentages[3].nan?
end
end
end
</pre>

According to the given test skeleton and the features we've implemented and to be implemented. Here are the testing ideas:

'''Context 1: When There Are No Bids or Assigned Teams'''

Test 1: Check if we get empty arrays for bids and assigned teams after running the "bidding_details" method.

Test 2: Check if the percentage of teams getting their #1, #2, and #3 choices are all 0.

'''Context 2: When There Are Bids and Assigned Teams for the Assignment'''

Test 3: We would first set up a known distribution of bids across different priority levels. After executing the "bidding_details" method, the test verifies that the returned count of bids for each priority level matches the expected distribution set up in the test environment.

Test 4: Ensure that the method correctly identifies and returns the assigned teams for each topic. In this test, the setup would include an assignment with pre-assigned teams to various topics. The "bidding_details" method is then called, and the test checks whether the method accurately returns the list of assigned teams for each topic, as per the test setup.

Test 5: Check if all teams bidding on a different topic, they all get the topic they want, and the percentage of #1 is 100%, while #2 and #3 are 0s.

Test 6: Check if all teams bidding on the same topic, only one team gets the topic they want, and the percentage of #1 is (1/teams)%, while #2 and #3 are 0s.

Test 7: Check if a team is a first/second/third team to bid on some topic, that topic is finally assigned to this team. In this case, #1, #2, or #3 is a non-zero value.

Test 8: Provide mocking data and we pre-calculate the percentage value of #1, #2 and #3, check if the calculated values are the same as ours.

== Relevant Links ==

'''Github Repository: ''' https://github.com/Shreshth-Malik/expertiza

== Team ==
'''Mentor'''

Edward F. Gehringer (efg ncsu.edu)

'''Members'''

Richard Li (rli14@ncsu.edu)

Shreshth Malik (smalik4@ncsu.edu)

Shuai Chen (schen76@ncsu.edu)

CSC/ECE 517 Fall 2023 - E2360. View for Results of Bidding (Phase2)

2023-12-05T07:33:54Z

Schen76:

== Motivation ==

The bidding view is needed because we don’t have a way of finding out whether the bidding algorithm is running correctly. This project is to add a bidding view to show how the topics are assigned to those teams who bid.

== Work Plan ==

Based on the project's objectives and feedback received from our mentor, we have identified specific areas for improvement:

1) Refactor variable names within methods such as "bidding_details" and variables like "Topic name" and "Bidding teams" to enhance clarity and specificity.

2) Adjust capitalization for certain components, ensuring that only the first word is capitalized for consistency.

3) Introduce calculations to determine percentages based on additional data, such as the total number of teams and the number of teams for each priority, within the "lottery_controller."

4) Conduct thorough testing of the modified controller and view to ensure optimal functionality.

[[File:Newfeature.jpg | 888px]]

== Design ==

To add functionality for showing the percentages of the number of teams that got their #1, #2, and #3 choices. We can follow these high-level steps:

'''Lottery_Controller:'''

i) Calculate the Total Number of Teams: Before we can calculate percentages, we need to know the total number of teams that participated in the bidding process. This will be our denominator in the percentage calculation.

ii) Calculate the Number of Teams for Each Priority: From our `bidding_details` method, we already have counts for how many teams bid on each topic as their #1, #2, and #3 choice (`@count1`, `@count2`, `@count3`). However, these counts are currently organized by topic. We would need to modify this to count how many teams got their #1, #2, and #3 choices as their assigned topic.

iii) Calculate Percentages: Once we have the number of teams that got their #1, #2, and #3 choices, we can calculate the percentages by dividing these numbers by the total number of teams and multiplying by 100.

'''Bidding_detail view:'''

i) Update the View and Display Percentages: Above the table in our previous view, we can add a section to display these percentages.

ii) Format the Display: We will use a bold heading for each percentage type and format the number to a fixed number of decimal places.

iii) Ensure Responsiveness: Make sure the display of these percentages adjusts well to different screen sizes, maintaining readability and layout consistency.

== Code Effort ==

Change in <code> app/controllers/lottery_controller.rb </code>

'''method 1: bidding_table_for_each_topic'''

This method generates a bidding table for each topic within an assignment. It performs several operations to gather and organize data related to topics, bids, and teams. Here's a breakdown of what the code does:

1. Fetch Assignment:

*It retrieves the assignment with the specified params[:id] from the database and stores it in the @assignment instance variable.

2. Fetch Topics:

*It retrieves all sign-up topics associated with the assignment and stores them in the @topics instance variable.

3. Fetch Bids and Assigned Teams:

For each topic in @topics, it:
*Retrieves all bids associated with that topic and stores them in a hash, where the key is the topic's ID and the value is an array of bids with their associated teams and priorities.
*Retrieves teams that are not waitlisted for the topic and stores them in a hash, again using the topic's ID as the key and an array of teams as the value.

4. Priority Count Calculation:

*It dynamically calculates and updates the counts for each bid priority level (1, 2, and 3) for each topic. These counts are stored in instance variables named @count1, @count2, and @count3. These instance variables are hashes where the keys are topic IDs, and the values are counts for each priority level.

5. Calculate Total Teams:

*It determines the total number of teams across all topics in the assignment by counting distinct team IDs among all non-waitlisted teams for the specified topics.

6. Calculate Priority Counts and Percentages:

*It calls two helper methods, calculate_priority_counts and calculate_percentages, to calculate the total counts of teams at each priority level and the corresponding percentages. The results are stored in the @priority_counts and @percentages instance variables, respectively.

<pre>
# Prepares data for displaying the bidding details for each topic within an assignment.
# It calculates the number of bids for each priority (1, 2, 3) per topic and also computes
# the overall percentages of teams that received their first, second, and third choice.
def bidding_table_for_each_topic
@assignment = Assignment.find(params[:id])
# Fetch all topics for the assignment
@topics = @assignment.sign_up_topics
# Fetch all bids for these topics
@bids_by_topic = {}
@assigned_teams_by_topic = {} # This will store the assigned teams for each topic
@topics.each do |topic|
# Assuming bids are stored with a topic_id, and each bid has a team associated with it
@bids_by_topic[topic.id] = Bid.where(topic_id: topic.id).map { |bid| { team: bid.team, priority: bid.priority } }
# Fetch teams that are not waitlisted for this topic
@assigned_teams_by_topic[topic.id] = SignedUpTeam.where(topic_id: topic.id, is_waitlisted: false).map(&:team)
# @count1[topic.id] += @bids_by_topic[topic.id].count { |bid| bid[:priority] == 1 }
# @count2[topic.id] += @bids_by_topic[topic.id].count { |bid| bid[:priority] == 2 }
# @count3[topic.id] += @bids_by_topic[topic.id].count { |bid| bid[:priority] == 3 }

# Dynamically initializing and updating @count1, @count2, and @count3
(1..3).each do |priority|
instance_variable_set("@count#{priority}", Hash.new(0)) unless instance_variable_defined?("@count#{priority}")
instance_variable_get("@count#{priority}")[topic.id] = @bids_by_topic[topic.id].count { |bid| bid[:priority] == priority }
end
end
# Calculate the total number of teams and percentages after fetching bid details
topic_ids = SignUpTopic.where(assignment_id: @assignment.id).pluck(:id)
@total_teams = SignedUpTeam.where(topic_id: topic_ids).distinct.count(:team_id)
@priority_counts = calculate_priority_counts(@assigned_teams_by_topic, @bids_by_topic)
@percentages = calculate_percentages(@priority_counts, @total_teams)

end
</pre>

'''method 2: calculate_priority_counts'''

1. Parameters
*assigned_teams_by_topic (Hash): A hash mapping each topic to an array of assigned teams.
*bids_by_topic (Hash): A hash mapping each topic to an array of bid objects, where each bid object is a hash containing team and priority information.

2. Functionality
*Initial Setup: Initializes a hash priority_counts with keys 1, 2, and 3, each having an initial value of 0. These keys represent the priority levels, and their values count the number of teams assigned to each level.

*Iterating Over Topics and Teams: Iterates over each topic and its associated teams found in assigned_teams_by_topic. For each team in a topic, the method searches bids_by_topic[topic_id] to find a bid made by the team.

*Updating Priority Counts: If a bid is found, the method increments the count in priority_counts corresponding to the priority level in the bid. This process effectively tallies the number of teams assigned to each priority level.

3. Returns
*priority_counts (Hash): A hash with keys 1, 2, and 3, where each key's value represents the count of teams assigned to that respective priority level.

<pre>
# Calculates the count of assigned teams for each priority level (1, 2, 3) across all topics.
# It checks each team associated with a topic and determines if the team's bid matches
# one of the priority levels, incrementing the respective count if so.
def calculate_priority_counts(assigned_teams_by_topic, bids_by_topic)
priority_counts = { 1 => 0, 2 => 0, 3 => 0 }
assigned_teams_by_topic.each do |topic_id, teams|
teams.each do |team|
bid_info = bids_by_topic[topic_id].find { |bid| bid[:team] == team }
priority_counts[bid_info[:priority]] += 1 if bid_info
end
end
priority_counts
end
</pre>

'''method 3: calculate_percentages'''

* This method calculates the percentages of teams that received their first, second, and third choice based on the counts of teams at each priority level.

<pre>
# Calculates the percentages of teams that received their first, second, and third choice
# based on the counts of teams at each priority level.
def calculate_percentages(priority_counts, total_teams)
priority_counts.transform_values { |count| (count.to_f / total_teams * 100).round(2) }
end
</pre>

Change in <code> app/views/lottery/bidding_table_for_each_topic.html.erb </code>

[[File:bidding_percentage.png | 888px]]

<pre>
<h3>Bidding Details for <%= @assignment.name %></h3>

<div class="percentages" style="margin-bottom: 20px; padding: 15px; border: 1px solid #ccc; border-radius: 5px; background-color: #f9f9f9;">
<h4 style="margin-bottom: 15px; border-bottom: 1px solid #eee; padding-bottom: 10px;">Percentage of Teams Getting Their Choices:</h4>
<ul style="list-style: none; padding: 0;">
<li><strong>#1 Choice:</strong> <span style="color: #4CAF50;"><%= @percentages[1] || 0 %> %</span></li>
<li><strong>#2 Choice:</strong> <span style="color: #FF9800;"><%= @percentages[2] || 0 %> %</span></li>
<li><strong>#3 Choice:</strong> <span style="color: #F44336;"><%= @percentages[3] || 0 %> %</span></li>
</ul>
</div>

<style>
.assigned-team {
background-color: yellow;
color: black;
}
.bids-column {
width: 100px; /* Adjust width as needed */
}
</style>

<table class="table table-bordered table-hover">
<thead>
<tr>
<th>Topic Name</th>
<th>Topic ID</th>
<th>Bidding Teams</th>
<th>#1 bids</th>
<th>#2 bids</th>
<th>#3 bids</th>
</tr>
</thead>
<tbody>
<% @topics.each do |topic| %>
<tr>
<td><%= topic.topic_name %></td>
<td><%= topic.id %></td>
<td>
<% @bids_by_topic[topic.id].each do |bid_info| %>
<% team = bid_info[:team] %>
<% assigned_team = @assigned_teams_by_topic[topic.id].include?(team) %>
<span class="<%= assigned_team ? 'assigned-team' : '' %>">
<%= team.name %> (#<%= bid_info[:priority] %>)
</span>
<% end %>
</td>
<td class="bids-column">
<% if @count1[topic.id] != 0%>
<%= @count1[topic.id] %>
<%else%>
–
<%end%>
</td>
<td class="bids-column">
<% if @count2[topic.id] != 0%>
<%= @count2[topic.id] %>
<%else%>
–
<%end%>
</td>
<td class="bids-column">
<% if @count3[topic.id] != 0%>
<%= @count3[topic.id] %>
<%else%>
–
<%end%>
</td>
</tr>
<% end %>
</tbody>
</table>

<a href="javascript:history.back()">Back</a>
</pre>

Added Rspec Testing <code> app/views/lottery/bidding_table_for_each_topic.html.erb </code>

<pre>
describe '#bidding_table_for_each_topic' do
before :each do
# Set the assignment id in the params
params = ActionController::Parameters.new(id: assignment.id)
allow(controller).to receive(:params).and_return(params)
end
it 'populates bids and assigned teams for each topic, handling topics with no teams' do
controller.bidding_table_for_each_topic
# Check if @bids_by_topic is populated correctly
expect(controller.instance_variable_get(:@bids_by_topic)[topic1.id].length).to eq(1)
expect(controller.instance_variable_get(:@bids_by_topic)[topic2.id].length).to eq(1)
# Check if @assigned_teams_by_topic is populated correctly, allowing for no teams
assigned_teams_topic1 = controller.instance_variable_get(:@assigned_teams_by_topic)[topic1.id]
if assigned_teams_topic1
expect(assigned_teams_topic1.length).to(satisfy { |value| (value == 0) || (value == 1) })
else
expect(assigned_teams_topic1).to be_nil
end
# Check the counts of bids for each priority level
# Ensure to adjust these based on what is set up in your test data
expect(controller.instance_variable_get(:@count1)[topic1.id]).to eq(1) # assuming there is one bid with priority 1 for topic1
expect(controller.instance_variable_get(:@count2)[topic1.id]).to eq(0) # assuming there are no bids with priority 2 for topic1
expect(controller.instance_variable_get(:@count3)[topic1.id]).to eq(0) # assuming there are no bids with priority 3 for topic1
end

it 'fetches all topics for the assignment' do
controller.bidding_table_for_each_topic
expect(controller.instance_variable_get(:@topics)).to match_array([topic1, topic2, topic3, topic4])
end

it 'correctly calculates priority counts for each topic' do
controller.bidding_table_for_each_topic

# Assuming you have a way to know the expected counts for each priority
expected_priority_counts = { 1 => 0,
2 => 0,
3 => 0 }

priority_counts = controller.instance_variable_get(:@priority_counts)
expect(priority_counts).to eq(expected_priority_counts)
end

it 'correctly calculates percentages for teams getting their choices' do
controller.bidding_table_for_each_topic

# Assuming you have a way to know the expected percentages
expected_percentages = { 1 => Float::NAN,
2 => Float::NAN,
3 => Float::NAN }

percentages = controller.instance_variable_get(:@percentages)
expect(percentages[1].nan?).to be true if expected_percentages[1].nan?
expect(percentages[2].nan?).to be true if expected_percentages[2].nan?
expect(percentages[3].nan?).to be true if expected_percentages[3].nan?
end
end
end
</pre>

== Test Plan ==

According to the given test skeleton and the features we've implemented and to be implemented. Here are the testing ideas:

'''Context 1: When There Are No Bids or Assigned Teams'''

Test 1: Check if we get empty arrays for bids and assigned teams after running the "bidding_details" method.

Test 2: Check if the percentage of teams getting their #1, #2, and #3 choices are all 0.

'''Context 2: When There Are Bids and Assigned Teams for the Assignment'''

Test 3: We would first set up a known distribution of bids across different priority levels. After executing the "bidding_details" method, the test verifies that the returned count of bids for each priority level matches the expected distribution set up in the test environment.

Test 4: Ensure that the method correctly identifies and returns the assigned teams for each topic. In this test, the setup would include an assignment with pre-assigned teams to various topics. The "bidding_details" method is then called, and the test checks whether the method accurately returns the list of assigned teams for each topic, as per the test setup.

Test 5: Check if all teams bidding on a different topic, they all get the topic they want, and the percentage of #1 is 100%, while #2 and #3 are 0s.

Test 6: Check if all teams bidding on the same topic, only one team gets the topic they want, and the percentage of #1 is (1/teams)%, while #2 and #3 are 0s.

Test 7: Check if a team is a first/second/third team to bid on some topic, that topic is finally assigned to this team. In this case, #1, #2, or #3 is a non-zero value.

Test 8: Provide mocking data and we pre-calculate the percentage value of #1, #2 and #3, check if the calculated values are the same as ours.

== Relevant Links ==

'''Github Repository: ''' https://github.com/Shreshth-Malik/expertiza

== Team ==
'''Mentor'''

Edward F. Gehringer (efg ncsu.edu)

'''Members'''

Richard Li (rli14@ncsu.edu)

Shreshth Malik (smalik4@ncsu.edu)

Shuai Chen (schen76@ncsu.edu)

File:Bidding percentage.png

2023-12-05T07:33:26Z

Schen76: Schen76 uploaded a new version of File:Bidding percentage.png

File:Bidding percentage.png

2023-12-05T07:29:32Z

Schen76:

CSC/ECE 517 Fall 2023 - E2360. View for Results of Bidding (Phase2)

2023-12-05T07:12:31Z

Schen76:

== Motivation ==

The bidding view is needed because we don’t have a way of finding out whether the bidding algorithm is running correctly. This project is to add a bidding view to show how the topics are assigned to those teams who bid.

== Work Plan ==

Based on the project's objectives and feedback received from our mentor, we have identified specific areas for improvement:

1) Refactor variable names within methods such as "bidding_details" and variables like "Topic name" and "Bidding teams" to enhance clarity and specificity.

2) Adjust capitalization for certain components, ensuring that only the first word is capitalized for consistency.

3) Introduce calculations to determine percentages based on additional data, such as the total number of teams and the number of teams for each priority, within the "lottery_controller."

4) Conduct thorough testing of the modified controller and view to ensure optimal functionality.

[[File:Newfeature.jpg | 888px]]

== Design ==

To add functionality for showing the percentages of the number of teams that got their #1, #2, and #3 choices. We can follow these high-level steps:

'''Lottery_Controller:'''

i) Calculate the Total Number of Teams: Before we can calculate percentages, we need to know the total number of teams that participated in the bidding process. This will be our denominator in the percentage calculation.

ii) Calculate the Number of Teams for Each Priority: From our `bidding_details` method, we already have counts for how many teams bid on each topic as their #1, #2, and #3 choice (`@count1`, `@count2`, `@count3`). However, these counts are currently organized by topic. We would need to modify this to count how many teams got their #1, #2, and #3 choices as their assigned topic.

iii) Calculate Percentages: Once we have the number of teams that got their #1, #2, and #3 choices, we can calculate the percentages by dividing these numbers by the total number of teams and multiplying by 100.

'''Bidding_detail view:'''

i) Update the View and Display Percentages: Above the table in our previous view, we can add a section to display these percentages.

ii) Format the Display: We will use a bold heading for each percentage type and format the number to a fixed number of decimal places.

iii) Ensure Responsiveness: Make sure the display of these percentages adjusts well to different screen sizes, maintaining readability and layout consistency.

== Code Effort ==

Change in <code> app/controllers/lottery_controller.rb </code>

method 1: bidding_table_for_each_topic

This method generates a bidding table for each topic within an assignment. It performs several operations to gather and organize data related to topics, bids, and teams. Here's a breakdown of what the code does:

1. Fetch Assignment:

*It retrieves the assignment with the specified params[:id] from the database and stores it in the @assignment instance variable.

2. Fetch Topics:

*It retrieves all sign-up topics associated with the assignment and stores them in the @topics instance variable.

3. Fetch Bids and Assigned Teams:

For each topic in @topics, it:
*Retrieves all bids associated with that topic and stores them in a hash, where the key is the topic's ID and the value is an array of bids with their associated teams and priorities.
*Retrieves teams that are not waitlisted for the topic and stores them in a hash, again using the topic's ID as the key and an array of teams as the value.

4. Priority Count Calculation:

*It dynamically calculates and updates the counts for each bid priority level (1, 2, and 3) for each topic. These counts are stored in instance variables named @count1, @count2, and @count3. These instance variables are hashes where the keys are topic IDs, and the values are counts for each priority level.

5. Calculate Total Teams:

*It determines the total number of teams across all topics in the assignment by counting distinct team IDs among all non-waitlisted teams for the specified topics.

6. Calculate Priority Counts and Percentages:

*It calls two helper methods, calculate_priority_counts and calculate_percentages, to calculate the total counts of teams at each priority level and the corresponding percentages. The results are stored in the @priority_counts and @percentages instance variables, respectively.

<pre>
# Prepares data for displaying the bidding details for each topic within an assignment.
# It calculates the number of bids for each priority (1, 2, 3) per topic and also computes
# the overall percentages of teams that received their first, second, and third choice.
def bidding_table_for_each_topic
@assignment = Assignment.find(params[:id])
# Fetch all topics for the assignment
@topics = @assignment.sign_up_topics
# Fetch all bids for these topics
@bids_by_topic = {}
@assigned_teams_by_topic = {} # This will store the assigned teams for each topic
@topics.each do |topic|
# Assuming bids are stored with a topic_id, and each bid has a team associated with it
@bids_by_topic[topic.id] = Bid.where(topic_id: topic.id).map { |bid| { team: bid.team, priority: bid.priority } }
# Fetch teams that are not waitlisted for this topic
@assigned_teams_by_topic[topic.id] = SignedUpTeam.where(topic_id: topic.id, is_waitlisted: false).map(&:team)
# @count1[topic.id] += @bids_by_topic[topic.id].count { |bid| bid[:priority] == 1 }
# @count2[topic.id] += @bids_by_topic[topic.id].count { |bid| bid[:priority] == 2 }
# @count3[topic.id] += @bids_by_topic[topic.id].count { |bid| bid[:priority] == 3 }

# Dynamically initializing and updating @count1, @count2, and @count3
(1..3).each do |priority|
instance_variable_set("@count#{priority}", Hash.new(0)) unless instance_variable_defined?("@count#{priority}")
instance_variable_get("@count#{priority}")[topic.id] = @bids_by_topic[topic.id].count { |bid| bid[:priority] == priority }
end
end
# Calculate the total number of teams and percentages after fetching bid details
topic_ids = SignUpTopic.where(assignment_id: @assignment.id).pluck(:id)
@total_teams = SignedUpTeam.where(topic_id: topic_ids).distinct.count(:team_id)
@priority_counts = calculate_priority_counts(@assigned_teams_by_topic, @bids_by_topic)
@percentages = calculate_percentages(@priority_counts, @total_teams)

end
</pre>

method 2: calculate_priority_counts
<pre>
# Calculates the count of assigned teams for each priority level (1, 2, 3) across all topics.
# It checks each team associated with a topic and determines if the team's bid matches
# one of the priority levels, incrementing the respective count if so.
def calculate_priority_counts(assigned_teams_by_topic, bids_by_topic)
priority_counts = { 1 => 0, 2 => 0, 3 => 0 }
assigned_teams_by_topic.each do |topic_id, teams|
teams.each do |team|
bid_info = bids_by_topic[topic_id].find { |bid| bid[:team] == team }
priority_counts[bid_info[:priority]] += 1 if bid_info
end
end
priority_counts
end
</pre>

method 3: calculate_percentages
<pre>
# Calculates the percentages of teams that received their first, second, and third choice
# based on the counts of teams at each priority level.
def calculate_percentages(priority_counts, total_teams)
priority_counts.transform_values { |count| (count.to_f / total_teams * 100).round(2) }
end
</pre>

Change <code> app/views/lottery/bidding_table_for_each_topic.html.erb </code>

<pre>
<h3>Bidding Details for <%= @assignment.name %></h3>

<div class="percentages" style="margin-bottom: 20px; padding: 15px; border: 1px solid #ccc; border-radius: 5px; background-color: #f9f9f9;">
<h4 style="margin-bottom: 15px; border-bottom: 1px solid #eee; padding-bottom: 10px;">Percentage of Teams Getting Their Choices:</h4>
<ul style="list-style: none; padding: 0;">
<li><strong>#1 Choice:</strong> <span style="color: #4CAF50;"><%= @percentages[1] || 0 %> %</span></li>
<li><strong>#2 Choice:</strong> <span style="color: #FF9800;"><%= @percentages[2] || 0 %> %</span></li>
<li><strong>#3 Choice:</strong> <span style="color: #F44336;"><%= @percentages[3] || 0 %> %</span></li>
</ul>
</div>

<style>
.assigned-team {
background-color: yellow;
color: black;
}
.bids-column {
width: 100px; /* Adjust width as needed */
}
</style>

<table class="table table-bordered table-hover">
<thead>
<tr>
<th>Topic Name</th>
<th>Topic ID</th>
<th>Bidding Teams</th>
<th>#1 bids</th>
<th>#2 bids</th>
<th>#3 bids</th>
</tr>
</thead>
<tbody>
<% @topics.each do |topic| %>
<tr>
<td><%= topic.topic_name %></td>
<td><%= topic.id %></td>
<td>
<% @bids_by_topic[topic.id].each do |bid_info| %>
<% team = bid_info[:team] %>
<% assigned_team = @assigned_teams_by_topic[topic.id].include?(team) %>
<span class="<%= assigned_team ? 'assigned-team' : '' %>">
<%= team.name %> (#<%= bid_info[:priority] %>)
</span>
<% end %>
</td>
<td class="bids-column">
<% if @count1[topic.id] != 0%>
<%= @count1[topic.id] %>
<%else%>
–
<%end%>
</td>
<td class="bids-column">
<% if @count2[topic.id] != 0%>
<%= @count2[topic.id] %>
<%else%>
–
<%end%>
</td>
<td class="bids-column">
<% if @count3[topic.id] != 0%>
<%= @count3[topic.id] %>
<%else%>
–
<%end%>
</td>
</tr>
<% end %>
</tbody>
</table>

<a href="javascript:history.back()">Back</a>
</pre>

Added Rspec Testing <code> app/views/lottery/bidding_table_for_each_topic.html.erb </code>

<pre>
describe '#bidding_table_for_each_topic' do
before :each do
# Set the assignment id in the params
params = ActionController::Parameters.new(id: assignment.id)
allow(controller).to receive(:params).and_return(params)
end
it 'populates bids and assigned teams for each topic, handling topics with no teams' do
controller.bidding_table_for_each_topic
# Check if @bids_by_topic is populated correctly
expect(controller.instance_variable_get(:@bids_by_topic)[topic1.id].length).to eq(1)
expect(controller.instance_variable_get(:@bids_by_topic)[topic2.id].length).to eq(1)
# Check if @assigned_teams_by_topic is populated correctly, allowing for no teams
assigned_teams_topic1 = controller.instance_variable_get(:@assigned_teams_by_topic)[topic1.id]
if assigned_teams_topic1
expect(assigned_teams_topic1.length).to(satisfy { |value| (value == 0) || (value == 1) })
else
expect(assigned_teams_topic1).to be_nil
end
# Check the counts of bids for each priority level
# Ensure to adjust these based on what is set up in your test data
expect(controller.instance_variable_get(:@count1)[topic1.id]).to eq(1) # assuming there is one bid with priority 1 for topic1
expect(controller.instance_variable_get(:@count2)[topic1.id]).to eq(0) # assuming there are no bids with priority 2 for topic1
expect(controller.instance_variable_get(:@count3)[topic1.id]).to eq(0) # assuming there are no bids with priority 3 for topic1
end

it 'fetches all topics for the assignment' do
controller.bidding_table_for_each_topic
expect(controller.instance_variable_get(:@topics)).to match_array([topic1, topic2, topic3, topic4])
end

it 'correctly calculates priority counts for each topic' do
controller.bidding_table_for_each_topic

# Assuming you have a way to know the expected counts for each priority
expected_priority_counts = { 1 => 0,
2 => 0,
3 => 0 }

priority_counts = controller.instance_variable_get(:@priority_counts)
expect(priority_counts).to eq(expected_priority_counts)
end

it 'correctly calculates percentages for teams getting their choices' do
controller.bidding_table_for_each_topic

# Assuming you have a way to know the expected percentages
expected_percentages = { 1 => Float::NAN,
2 => Float::NAN,
3 => Float::NAN }

percentages = controller.instance_variable_get(:@percentages)
expect(percentages[1].nan?).to be true if expected_percentages[1].nan?
expect(percentages[2].nan?).to be true if expected_percentages[2].nan?
expect(percentages[3].nan?).to be true if expected_percentages[3].nan?
end
end
end
</pre>

== Test Plan ==

According to the given test skeleton and the features we've implemented and to be implemented. Here are the testing ideas:

'''Context 1: When There Are No Bids or Assigned Teams'''

Test 1: Check if we get empty arrays for bids and assigned teams after running the "bidding_details" method.

Test 2: Check if the percentage of teams getting their #1, #2, and #3 choices are all 0.

'''Context 2: When There Are Bids and Assigned Teams for the Assignment'''

Test 3: We would first set up a known distribution of bids across different priority levels. After executing the "bidding_details" method, the test verifies that the returned count of bids for each priority level matches the expected distribution set up in the test environment.

Test 4: Ensure that the method correctly identifies and returns the assigned teams for each topic. In this test, the setup would include an assignment with pre-assigned teams to various topics. The "bidding_details" method is then called, and the test checks whether the method accurately returns the list of assigned teams for each topic, as per the test setup.

Test 5: Check if all teams bidding on a different topic, they all get the topic they want, and the percentage of #1 is 100%, while #2 and #3 are 0s.

Test 6: Check if all teams bidding on the same topic, only one team gets the topic they want, and the percentage of #1 is (1/teams)%, while #2 and #3 are 0s.

Test 7: Check if a team is a first/second/third team to bid on some topic, that topic is finally assigned to this team. In this case, #1, #2, or #3 is a non-zero value.

Test 8: Provide mocking data and we pre-calculate the percentage value of #1, #2 and #3, check if the calculated values are the same as ours.

== Relevant Links ==

'''Github Repository: ''' https://github.com/Shreshth-Malik/expertiza

== Team ==
'''Mentor'''

Edward F. Gehringer (efg ncsu.edu)

'''Members'''

Richard Li (rli14@ncsu.edu)

Shreshth Malik (smalik4@ncsu.edu)

Shuai Chen (schen76@ncsu.edu)

CSC/ECE 517 Fall 2023 - E2360. View for Results of Bidding (Phase2)

2023-12-05T06:40:21Z

Schen76:

CSC/ECE 517 Fall 2023 - E2360. View for Results of Bidding (Phase2)

2023-12-05T03:03:59Z

Schen76:

== Motivation ==

The bidding view was needed because we didn’t have a way of finding out whether the bidding algorithm was running correctly. This project is to add tests and determine whether the algorithm is running correctly, and, if not, debug it.

== Work Plan ==

Based on the project's objectives and feedback received from our mentor, we have identified specific areas for improvement:

i) Refactor variable names within methods such as "bidding_details" and variables like "Topic name" and "Bidding teams" to enhance clarity and specificity.

ii) Adjust capitalization for certain components, ensuring that only the first word is capitalized for consistency.

iii) Introduce calculations to determine percentages based on additional data, such as the total number of teams and the number of teams for each priority, within the "lottery_controller."

iv) Conduct thorough testing of the modified controller and view to ensure optimal functionality.

[[File:Newfeature.jpg | 888px]]

== Design ==

To add functionality for showing the percentages of the number of teams that got their #1, #2, and #3 choices. We can follow these high-level steps:

'''Lottery_Controller:'''

i) Calculate the Total Number of Teams: Before we can calculate percentages, we need to know the total number of teams that participated in the bidding process. This will be our denominator in the percentage calculation.

ii) Calculate the Number of Teams for Each Priority: From our `bidding_details` method, we already have counts for how many teams bid on each topic as their #1, #2, and #3 choice (`@count1`, `@count2`, `@count3`). However, these counts are currently organized by topic. We would need to modify this to count how many teams got their #1, #2, and #3 choices as their assigned topic.

iii) Calculate Percentages: Once we have the number of teams that got their #1, #2, and #3 choices, we can calculate the percentages by dividing these numbers by the total number of teams and multiplying by 100.

'''Bidding_detail view:'''

i) Update the View and Display Percentages: Above the table in our previous view, we can add a section to display these percentages.

ii) Format the Display: We will use a bold heading for each percentage type and format the number to a fixed number of decimal places.

iii) Ensure Responsiveness: Make sure the display of these percentages adjusts well to different screen sizes, maintaining readability and layout consistency.

== Test Plan ==

According to the given test skeleton and the features we've implemented and to be implemented. Here are the testing ideas:

'''Context 1: When There Are No Bids or Assigned Teams'''

Test 1: Check if we get empty arrays for bids and assigned teams after running the "bidding_details" method.

Test 2: Check if the percentage of teams getting their #1, #2, and #3 choices are all 0.

'''Context 2: When There Are Bids and Assigned Teams for the Assignment'''

Test 3: We would first set up a known distribution of bids across different priority levels. After executing the "bidding_details" method, the test verifies that the returned count of bids for each priority level matches the expected distribution set up in the test environment.

Test 4: Ensure that the method correctly identifies and returns the assigned teams for each topic. In this test, the setup would include an assignment with pre-assigned teams to various topics. The "bidding_details" method is then called, and the test checks whether the method accurately returns the list of assigned teams for each topic, as per the test setup.

Test 5: Check if all teams bidding on a different topic, they all get the topic they want, and the percentage of #1 is 100%, while #2 and #3 are 0s.

Test 6: Check if all teams bidding on the same topic, only one team gets the topic they want, and the percentage of #1 is (1/teams)%, while #2 and #3 are 0s.

Test 7: Check if a team is a first/second/third team to bid on some topic, that topic is finally assigned to this team. In this case, #1, #2, or #3 is a non-zero value.

Test 8: Provide mocking data and we pre-calculate the percentage value of #1, #2 and #3, check if the calculated values are the same as ours.

== Relevant Links ==

'''Github Repository: ''' https://github.com/Shreshth-Malik/expertiza

== Team ==
'''Mentor'''

Edward F. Gehringer (efg ncsu.edu)

'''Members'''

Richard Li (rli14@ncsu.edu)

Shreshth Malik (smalik4@ncsu.edu)

Shuai Chen (schen76@ncsu.edu)

CSC/ECE 517 Fall 2023 - E2360. View for Results of Bidding (Phase2)

2023-12-05T02:54:48Z

Schen76:

== Design Doc ==

==== 1. Work Plan ====

Based on the project's objectives and feedback received from our mentor, we have identified specific areas for improvement:

i) Refactor variable names within methods such as "bidding_details" and variables like "Topic name" and "Bidding teams" to enhance clarity and specificity.

ii) Adjust capitalization for certain components, ensuring that only the first word is capitalized for consistency.

iii) Introduce calculations to determine percentages based on additional data, such as the total number of teams and the number of teams for each priority, within the "lottery_controller."

iv) Conduct thorough testing of the modified controller and view to ensure optimal functionality.

[[File:Newfeature.jpg | 888px]]

==== 2. Design ====

To add functionality for showing the percentages of the number of teams that got their #1, #2, and #3 choices. We can follow these high-level steps:

'''Lottery_Controller:'''

i) Calculate the Total Number of Teams: Before we can calculate percentages, we need to know the total number of teams that participated in the bidding process. This will be our denominator in the percentage calculation.

ii) Calculate the Number of Teams for Each Priority: From our `bidding_details` method, we already have counts for how many teams bid on each topic as their #1, #2, and #3 choice (`@count1`, `@count2`, `@count3`). However, these counts are currently organized by topic. We would need to modify this to count how many teams got their #1, #2, and #3 choices as their assigned topic.

iii) Calculate Percentages: Once we have the number of teams that got their #1, #2, and #3 choices, we can calculate the percentages by dividing these numbers by the total number of teams and multiplying by 100.

'''Bidding_detail view:'''

i) Update the View and Display Percentages: Above the table in our previous view, we can add a section to display these percentages.

ii) Format the Display: We will use a bold heading for each percentage type and format the number to a fixed number of decimal places.

iii) Ensure Responsiveness: Make sure the display of these percentages adjusts well to different screen sizes, maintaining readability and layout consistency.

==== 3. Test Plan ====

According to the given test skeleton and the features we've implemented and to be implemented. Here are the testing ideas:

'''Context 1: When There Are No Bids or Assigned Teams'''

Test 1: Check if we get empty arrays for bids and assigned teams after running the "bidding_details" method.

Test 2: Check if the percentage of teams getting their #1, #2, and #3 choices are all 0.

'''Context 2: When There Are Bids and Assigned Teams for the Assignment'''

Test 3: We would first set up a known distribution of bids across different priority levels. After executing the "bidding_details" method, the test verifies that the returned count of bids for each priority level matches the expected distribution set up in the test environment.

Test 4: Ensure that the method correctly identifies and returns the assigned teams for each topic. In this test, the setup would include an assignment with pre-assigned teams to various topics. The "bidding_details" method is then called, and the test checks whether the method accurately returns the list of assigned teams for each topic, as per the test setup.

Test 5: Check if all teams bidding on a different topic, they all get the topic they want, and the percentage of #1 is 100%, while #2 and #3 are 0s.

Test 6: Check if all teams bidding on the same topic, only one team gets the topic they want, and the percentage of #1 is (1/teams)%, while #2 and #3 are 0s.

Test 7: Check if a team is a first/second/third team to bid on some topic, that topic is finally assigned to this team. In this case, #1, #2, or #3 is a non-zero value.

Test 8: Provide mocking data and we pre-calculate the percentage value of #1, #2 and #3, check if the calculated values are the same as ours.

== Relevant Links ==

'''Github Repository: ''' https://github.com/Shreshth-Malik/expertiza

== Team ==
'''Mentor'''

Edward F. Gehringer (efg ncsu.edu)

'''Members'''

Richard Li (rli14@ncsu.edu)

Shreshth Malik (smalik4@ncsu.edu)

Shuai Chen (schen76@ncsu.edu)

CSC/ECE 517 Fall 2023 - E2360. View for Results of Bidding (Phase2)

2023-11-16T03:48:56Z

Schen76: /* 1. Work Plan */

File:Newfeature.jpg

2023-11-16T03:47:58Z

Schen76:

CSC/ECE 517 Fall 2023

2023-11-16T03:43:43Z

Schen76:

* [[CSC/ECE 517 Fall 2023 - E2350. Allow reviewers to bid on what to review]]
* [[CSC/ECE 517 Fall 2023 - E2351. Finish mentor management for assignments without topics]]
* [[CSC/ECE 517 Fall 2023 - E2352. Fix "Back" link on “New Late Policy” page]]
* [[CSC/ECE 517 Fall 2023 - E2353. Further refactoring and improvement of review mapping helper]]
* [[CSC/ECE 517 Fall 2023 - E2355. Improving Search Facility In Expertiza]]
* [[CSC/ECE 517 Fall 2023 - E2356. Refactor review_mapping_controller.rb]]
* [[CSC/ECE 517 Fall 2023 - E2357. Refactor sign_up_sheet_controller.rb]]
* [[CSC/ECE 517 Fall 2023 - E2358. Refactor student_quizzes_controller.rb]]
* [[CSC/ECE 517 Fall 2023 - E2359. Refactor user_controller.rb, user.rb, and its child classes]]
* [[CSC/ECE 517 Fall 2023 - E2360. View for Results of Bidding]]
* [[CSC/ECE 517 Fall 2023 - E2360. View for Results of Bidding (Phase2)]]
* [[CSC/ECE 517 Fall 2023 - E2361. Create a page to create and update a Questionnaire in ReactJS]]
* [[CSC/ECE 517 Fall 2023 - E2362. Create a page to edit an Assignment's due date in ReactJS]]
* [[CSC/ECE 517 Fall 2023 - E2363. Create a UI for Assignment Edit page "Etc" tab in ReactJS]]
* [[CSC/ECE 517 Fall 2023 - E2364. Create a UI for Course's & Assignment's "Add Participants" page]]
* [[CSC/ECE 517 Fall 2023 - E2365. Create a user interface for Questionnaire in ReactJS]]
* [[CSC/ECE 517 Fall 2023 - E2387. Reimplement Teams backend (Phase 2)]]
* [[CSC/ECE 517 Fall 2023 - E2366. Reimplement assignment model and assignment controller]]
* [[CSC/ECE 517 Fall 2023 - E2366. Reimplement assignment model and assignment controller (Phase 2)]]
* [[CSC/ECE 517 Fall 2023 - E2367. Reimplement participants_controller.rb, participants.rb and its child classes]]
* [[CSC/ECE 517 Fall 2023 - E2368. Reimplement of due_date.rb]]
* [[CSC/ECE 517 Fall 2023 - E2369. Reimplement duties controller.rb and badges controller.rb]]
* [[CSC/ECE 517 Fall 2023 - E2370. Reimplement join team requests controller]]
* [[CSC/ECE 517 Fall 2023 - E2371. Reimplement quiz_questionnaires_controller]]
* [[CSC/ECE 517 Fall 2023 - E2373. Reimplementation of teams controller]]
* [[CSC/ECE 517 Fall 2023 - E2373. Reimplement teams_controllers.rb]]
* [[CSC/ECE 517 Fall 2023 - E2374. Reimplement the Question hierarchy]]
* [[CSC/ECE 517 Fall 2023 - E2375. Reimplement Waitlists]]
* [[CSC/ECE 517 Fall 2023 - E2376. Reimplement student_quizzes_controller.rb]]
* [[CSC/ECE 517 Fall 2023 - E2379. Reimplement authorization_helper.rb]]
* [[CSC/ECE 517 Fall 2023 - E2380. Reimplement frontend for Courses]]
* [[CSC/ECE 517 Fall 2023 - E2381. Reimplement frontend for Assignments]]
* [[CSC/ECE 517 Fall 2023 - E2382. Optimizing the LatePoliciesController]]
* [[CSC/ECE 517 Fall 2023 - E2383. Grading Audit Trail]]
* [[CSC/ECE 517 Fall 2023 - E2384. Reimplement user_controller.rb, user.rb and its child classes]]
* [[CSC/ECE 517 Fall 2023 - E2385. Create a Courses User interface in ReactJS]]
* [[CSC/ECE 517 Fall 2023 - E2386. Reimplement teams_users backend]]
* [[CSC/ECE 517 Fall 2023 - E2377. Reimplement impersonating users (functionality within impersonate_controller.rb)]]
* [[CSC/ECE 517 Fall 2023 - NTX-1 Adding Snapshot Controller/API and CRDs]]
* [[CSC/ECE 517 Fall 2023 - NTX-2 Observability and Debuggability]]
* [[CSC/ECE 517 Fall 2023 - NTX-3 Usability and Security]]
* [[CSC/ECE 517 Fall 2023 - NTX-4 Extend NDB Operator capabilities to support Postgres HA]]
* [[CSC/ECE 517 Fall 2023 - G2350. Add GitLab support for using GraphQL to query user metrics 1]]
* [[CSC/ECE 517 Fall 2023 - G2352. Add GitLab support for using GraphQL to query repository information]]
* [[CSC/ECE 517 Fall 2023 - E2375. Refactor classes relating to signing up for topics]]

CSC/ECE 517 Fall 2023

2023-11-16T03:43:32Z

Schen76:

* [[CSC/ECE 517 Fall 2023 - E2350. Allow reviewers to bid on what to review]]
* [[CSC/ECE 517 Fall 2023 - E2351. Finish mentor management for assignments without topics]]
* [[CSC/ECE 517 Fall 2023 - E2352. Fix "Back" link on “New Late Policy” page]]
* [[CSC/ECE 517 Fall 2023 - E2353. Further refactoring and improvement of review mapping helper]]
* [[CSC/ECE 517 Fall 2023 - E2355. Improving Search Facility In Expertiza]]
* [[CSC/ECE 517 Fall 2023 - E2356. Refactor review_mapping_controller.rb]]
* [[CSC/ECE 517 Fall 2023 - E2357. Refactor sign_up_sheet_controller.rb]]
* [[CSC/ECE 517 Fall 2023 - E2358. Refactor student_quizzes_controller.rb]]
* [[CSC/ECE 517 Fall 2023 - E2359. Refactor user_controller.rb, user.rb, and its child classes]]
* [[CSC/ECE 517 Fall 2023 - E2360. View for Results of Bidding]]
* [[CSC/ECE 517 Fall 2023 - E2360. View for Results of Bidding(Phase2)]]
* [[CSC/ECE 517 Fall 2023 - E2361. Create a page to create and update a Questionnaire in ReactJS]]
* [[CSC/ECE 517 Fall 2023 - E2362. Create a page to edit an Assignment's due date in ReactJS]]
* [[CSC/ECE 517 Fall 2023 - E2363. Create a UI for Assignment Edit page "Etc" tab in ReactJS]]
* [[CSC/ECE 517 Fall 2023 - E2364. Create a UI for Course's & Assignment's "Add Participants" page]]
* [[CSC/ECE 517 Fall 2023 - E2365. Create a user interface for Questionnaire in ReactJS]]
* [[CSC/ECE 517 Fall 2023 - E2387. Reimplement Teams backend (Phase 2)]]
* [[CSC/ECE 517 Fall 2023 - E2366. Reimplement assignment model and assignment controller]]
* [[CSC/ECE 517 Fall 2023 - E2366. Reimplement assignment model and assignment controller (Phase 2)]]
* [[CSC/ECE 517 Fall 2023 - E2367. Reimplement participants_controller.rb, participants.rb and its child classes]]
* [[CSC/ECE 517 Fall 2023 - E2368. Reimplement of due_date.rb]]
* [[CSC/ECE 517 Fall 2023 - E2369. Reimplement duties controller.rb and badges controller.rb]]
* [[CSC/ECE 517 Fall 2023 - E2370. Reimplement join team requests controller]]
* [[CSC/ECE 517 Fall 2023 - E2371. Reimplement quiz_questionnaires_controller]]
* [[CSC/ECE 517 Fall 2023 - E2373. Reimplementation of teams controller]]
* [[CSC/ECE 517 Fall 2023 - E2373. Reimplement teams_controllers.rb]]
* [[CSC/ECE 517 Fall 2023 - E2374. Reimplement the Question hierarchy]]
* [[CSC/ECE 517 Fall 2023 - E2375. Reimplement Waitlists]]
* [[CSC/ECE 517 Fall 2023 - E2376. Reimplement student_quizzes_controller.rb]]
* [[CSC/ECE 517 Fall 2023 - E2379. Reimplement authorization_helper.rb]]
* [[CSC/ECE 517 Fall 2023 - E2380. Reimplement frontend for Courses]]
* [[CSC/ECE 517 Fall 2023 - E2381. Reimplement frontend for Assignments]]
* [[CSC/ECE 517 Fall 2023 - E2382. Optimizing the LatePoliciesController]]
* [[CSC/ECE 517 Fall 2023 - E2383. Grading Audit Trail]]
* [[CSC/ECE 517 Fall 2023 - E2384. Reimplement user_controller.rb, user.rb and its child classes]]
* [[CSC/ECE 517 Fall 2023 - E2385. Create a Courses User interface in ReactJS]]
* [[CSC/ECE 517 Fall 2023 - E2386. Reimplement teams_users backend]]
* [[CSC/ECE 517 Fall 2023 - E2377. Reimplement impersonating users (functionality within impersonate_controller.rb)]]
* [[CSC/ECE 517 Fall 2023 - NTX-1 Adding Snapshot Controller/API and CRDs]]
* [[CSC/ECE 517 Fall 2023 - NTX-2 Observability and Debuggability]]
* [[CSC/ECE 517 Fall 2023 - NTX-3 Usability and Security]]
* [[CSC/ECE 517 Fall 2023 - NTX-4 Extend NDB Operator capabilities to support Postgres HA]]
* [[CSC/ECE 517 Fall 2023 - G2350. Add GitLab support for using GraphQL to query user metrics 1]]
* [[CSC/ECE 517 Fall 2023 - G2352. Add GitLab support for using GraphQL to query repository information]]
* [[CSC/ECE 517 Fall 2023 - E2375. Refactor classes relating to signing up for topics]]

CSC/ECE 517 Fall 2023

2023-11-16T03:42:57Z

Schen76:

* [[CSC/ECE 517 Fall 2023 - E2350. Allow reviewers to bid on what to review]]
* [[CSC/ECE 517 Fall 2023 - E2351. Finish mentor management for assignments without topics]]
* [[CSC/ECE 517 Fall 2023 - E2352. Fix "Back" link on “New Late Policy” page]]
* [[CSC/ECE 517 Fall 2023 - E2353. Further refactoring and improvement of review mapping helper]]
* [[CSC/ECE 517 Fall 2023 - E2355. Improving Search Facility In Expertiza]]
* [[CSC/ECE 517 Fall 2023 - E2356. Refactor review_mapping_controller.rb]]
* [[CSC/ECE 517 Fall 2023 - E2357. Refactor sign_up_sheet_controller.rb]]
* [[CSC/ECE 517 Fall 2023 - E2358. Refactor student_quizzes_controller.rb]]
* [[CSC/ECE 517 Fall 2023 - E2359. Refactor user_controller.rb, user.rb, and its child classes]]
* [[CSC/ECE 517 Fall 2023 - E2360. View for Results of Bidding]]
* [[CSC/ECE_517_Fall_2023_-_E2360._View_for_Results_of_Bidding_(Phase2)]]
* [[CSC/ECE 517 Fall 2023 - E2361. Create a page to create and update a Questionnaire in ReactJS]]
* [[CSC/ECE 517 Fall 2023 - E2362. Create a page to edit an Assignment's due date in ReactJS]]
* [[CSC/ECE 517 Fall 2023 - E2363. Create a UI for Assignment Edit page "Etc" tab in ReactJS]]
* [[CSC/ECE 517 Fall 2023 - E2364. Create a UI for Course's & Assignment's "Add Participants" page]]
* [[CSC/ECE 517 Fall 2023 - E2365. Create a user interface for Questionnaire in ReactJS]]
* [[CSC/ECE 517 Fall 2023 - E2387. Reimplement Teams backend (Phase 2)]]
* [[CSC/ECE 517 Fall 2023 - E2366. Reimplement assignment model and assignment controller]]
* [[CSC/ECE 517 Fall 2023 - E2366. Reimplement assignment model and assignment controller (Phase 2)]]
* [[CSC/ECE 517 Fall 2023 - E2367. Reimplement participants_controller.rb, participants.rb and its child classes]]
* [[CSC/ECE 517 Fall 2023 - E2368. Reimplement of due_date.rb]]
* [[CSC/ECE 517 Fall 2023 - E2369. Reimplement duties controller.rb and badges controller.rb]]
* [[CSC/ECE 517 Fall 2023 - E2370. Reimplement join team requests controller]]
* [[CSC/ECE 517 Fall 2023 - E2371. Reimplement quiz_questionnaires_controller]]
* [[CSC/ECE 517 Fall 2023 - E2373. Reimplementation of teams controller]]
* [[CSC/ECE 517 Fall 2023 - E2373. Reimplement teams_controllers.rb]]
* [[CSC/ECE 517 Fall 2023 - E2374. Reimplement the Question hierarchy]]
* [[CSC/ECE 517 Fall 2023 - E2375. Reimplement Waitlists]]
* [[CSC/ECE 517 Fall 2023 - E2376. Reimplement student_quizzes_controller.rb]]
* [[CSC/ECE 517 Fall 2023 - E2379. Reimplement authorization_helper.rb]]
* [[CSC/ECE 517 Fall 2023 - E2380. Reimplement frontend for Courses]]
* [[CSC/ECE 517 Fall 2023 - E2381. Reimplement frontend for Assignments]]
* [[CSC/ECE 517 Fall 2023 - E2382. Optimizing the LatePoliciesController]]
* [[CSC/ECE 517 Fall 2023 - E2383. Grading Audit Trail]]
* [[CSC/ECE 517 Fall 2023 - E2384. Reimplement user_controller.rb, user.rb and its child classes]]
* [[CSC/ECE 517 Fall 2023 - E2385. Create a Courses User interface in ReactJS]]
* [[CSC/ECE 517 Fall 2023 - E2386. Reimplement teams_users backend]]
* [[CSC/ECE 517 Fall 2023 - E2377. Reimplement impersonating users (functionality within impersonate_controller.rb)]]
* [[CSC/ECE 517 Fall 2023 - NTX-1 Adding Snapshot Controller/API and CRDs]]
* [[CSC/ECE 517 Fall 2023 - NTX-2 Observability and Debuggability]]
* [[CSC/ECE 517 Fall 2023 - NTX-3 Usability and Security]]
* [[CSC/ECE 517 Fall 2023 - NTX-4 Extend NDB Operator capabilities to support Postgres HA]]
* [[CSC/ECE 517 Fall 2023 - G2350. Add GitLab support for using GraphQL to query user metrics 1]]
* [[CSC/ECE 517 Fall 2023 - G2352. Add GitLab support for using GraphQL to query repository information]]
* [[CSC/ECE 517 Fall 2023 - E2375. Refactor classes relating to signing up for topics]]

CSC/ECE 517 Fall 2023 - E2360. View for Results of Bidding (Phase2)

2023-11-16T03:41:52Z

Schen76:

== Design Doc ==

==== 1. Work Plan ====

Based on the project's objectives and feedback received from our mentor, we have identified specific areas for improvement:

i) Refactor variable names within methods such as "bidding_details" and variables like "Topic name" and "Bidding teams" to enhance clarity and specificity.

ii) Adjust capitalization for certain components, ensuring that only the first word is capitalized for consistency.

iii) Introduce calculations to determine percentages based on additional data, such as the total number of teams and the number of teams for each priority, within the "lottery_controller."

iv) Conduct thorough testing of the modified controller and view to ensure optimal functionality.

==== 2. Design ====

To add functionality for showing the percentages of the number of teams that got their #1, #2, and #3 choices. We can follow these high-level steps:

'''Lottery_Controller:'''

i) Calculate the Total Number of Teams: Before we can calculate percentages, we need to know the total number of teams that participated in the bidding process. This will be our denominator in the percentage calculation.

ii) Calculate the Number of Teams for Each Priority: From our `bidding_details` method, we already have counts for how many teams bid on each topic as their #1, #2, and #3 choice (`@count1`, `@count2`, `@count3`). However, these counts are currently organized by topic. We would need to modify this to count how many teams got their #1, #2, and #3 choices as their assigned topic.

iii) Calculate Percentages: Once we have the number of teams that got their #1, #2, and #3 choices, we can calculate the percentages by dividing these numbers by the total number of teams and multiplying by 100.

'''Bidding_detail view:'''

i) Update the View and Display Percentages: Above the table in our previous view, we can add a section to display these percentages.

ii) Format the Display: We will use a bold heading for each percentage type and format the number to a fixed number of decimal places.

iii) Ensure Responsiveness: Make sure the display of these percentages adjusts well to different screen sizes, maintaining readability and layout consistency.

==== 3. Test Plan ====

According to the given test skeleton and the features we've implemented and to be implemented. Here are the testing ideas:

'''Context 1: When There Are No Bids or Assigned Teams'''

Test 1: Check if we get empty arrays for bids and assigned teams after running the "bidding_details" method.

Test 2: Check if the percentage of teams getting their #1, #2, and #3 choices are all 0.

'''Context 2: When There Are Bids and Assigned Teams for the Assignment'''

Test 3: We would first set up a known distribution of bids across different priority levels. After executing the "bidding_details" method, the test verifies that the returned count of bids for each priority level matches the expected distribution set up in the test environment.

Test 4: Ensure that the method correctly identifies and returns the assigned teams for each topic. In this test, the setup would include an assignment with pre-assigned teams to various topics. The "bidding_details" method is then called, and the test checks whether the method accurately returns the list of assigned teams for each topic, as per the test setup.

Test 5: Check if all teams bidding on a different topic, they all get the topic they want, and the percentage of #1 is 100%, while #2 and #3 are 0s.

Test 6: Check if all teams bidding on the same topic, only one team gets the topic they want, and the percentage of #1 is (1/teams)%, while #2 and #3 are 0s.

Test 7: Check if a team is a first/second/third team to bid on some topic, that topic is finally assigned to this team. In this case, #1, #2, or #3 is a non-zero value.

Test 8: Provide mocking data and we pre-calculate the percentage value of #1, #2 and #3, check if the calculated values are the same as ours.

CSC/ECE 517 Fall 2023 - E2360. View for Results of Bidding (Phase2)

2023-11-16T02:41:03Z

Schen76:

CSC/ECE 517 Fall 2023 - E2360. View for Results of Bidding (Phase2)

2023-11-16T02:38:53Z

Schen76:

== Design Doc ==

''' 1. Work Plan '''

Based on the project's objectives and feedback received from our mentor, we have identified specific areas for improvement:

i) Refactor variable names within methods such as "bidding_details" and variables like "Topic name" and "Bidding teams" to enhance clarity and specificity.

ii) Adjust capitalization for certain components, ensuring that only the first word is capitalized for consistency.

iii) Introduce calculations to determine percentages based on additional data, such as the total number of teams and the number of teams for each priority, within the "lottery_controller."

iv) Conduct thorough testing of the modified controller and view to ensure optimal functionality.

''' 2. Design '''

To add functionality for showing the percentages of the number of teams that got their #1, #2, and #3 choices. We can follow these high-level steps:

Lottery_Controller:

i) Calculate the Total Number of Teams: Before we can calculate percentages, we need to know the total number of teams that participated in the bidding process. This will be our denominator in the percentage calculation.

ii) Calculate the Number of Teams for Each Priority: From our `bidding_details` method, we already have counts for how many teams bid on each topic as their #1, #2, and #3 choice (`@count1`, `@count2`, `@count3`). However, these counts are currently organized by topic. We would need to modify this to count how many teams got their #1, #2, and #3 choices as their assigned topic.

iii) Calculate Percentages: Once we have the number of teams that got their #1, #2, and #3 choices, we can calculate the percentages by dividing these numbers by the total number of teams and multiplying by 100.

Bidding_detail view:

i) Update the View and Display Percentages: Above the table in our previous view, we can add a section to display these percentages.

ii) Format the Display: We will use a bold heading for each percentage type and format the number to a fixed number of decimal places.

iii) Ensure Responsiveness: Make sure the display of these percentages adjusts well to different screen sizes, maintaining readability and layout consistency.

''' 3. Test Plan '''

CSC/ECE 517 Fall 2023 - E2360. View for Results of Bidding (Phase2)

2023-11-16T02:36:52Z

Schen76: Created page with " == Design Doc == ''' 1. Work Plan ''' Based on the project's objectives and feedback received from our mentor, we have identified specific areas for improvement: i) Refact..."

CSC/ECE 517 Fall 2023 - E2360. View for Results of Bidding

2023-11-06T16:30:55Z

Schen76:

CSC/ECE 517 Fall 2023 - E2360. View for Results of Bidding

2023-11-06T16:29:15Z

Schen76:

CSC/ECE 517 Fall 2023 - E2360. View for Results of Bidding

2023-11-06T16:26:13Z

Schen76:

CSC/ECE 517 Fall 2023

2023-11-05T23:56:43Z

Schen76:

* [[CSC/ECE 517 Fall 2023 - E2350. Allow reviewers to bid on what to review]]
* [[CSC/ECE 517 Fall 2023 - E2351. Finish mentor management for assignments without topics]]
* [[CSC/ECE 517 Fall 2023 - E2353. Further refactoring and improvement of review mapping helper]]
* [[CSC/ECE 517 Fall 2023 - E2355. Improving Search Facility In Expertiza]]
* [[CSC/ECE 517 Fall 2023 - E2356. Refactor review_mapping_controller.rb]]
* [[CSC/ECE 517 Fall 2023 - E2357. Refactor sign_up_sheet_controller.rb]]
* [[CSC/ECE 517 Fall 2023 - E2358. Refactor student_quizzes_controller.rb]]
* [[CSC/ECE 517 Fall 2023 - E2359. Refactor user_controller.rb, user.rb, and its child classes]]
* [[CSC/ECE 517 Fall 2023 - E2360. View for Results of Bidding]]
* [[CSC/ECE 517 Fall 2023 - E2361. Create a page to create and update a Questionnaire in ReactJS]]
* [[CSC/ECE 517 Fall 2023 - E2362. Create a page to edit an Assignment's due date in ReactJS]]
* [[CSC/ECE 517 Fall 2023 - E2363. Create a UI for Assignment Edit page "Etc" tab in ReactJS]]
* [[CSC/ECE 517 Fall 2023 - E2364. Create a UI for Course's & Assignment's "Add Participants" page]]
* [[CSC/ECE 517 Fall 2023 - E2365. Create a user interface for Questionnaire in ReactJS]]
* [[CSC/ECE 517 Fall 2023 - E2366. Reimplement assignment model and assignment controller]]
* [[CSC/ECE 517 Fall 2023 - E2367. Reimplement participants_controller.rb, participants.rb and its child classes]]
* [[CSC/ECE 517 Fall 2023 - E2368. Reimplement of due_date.rb]]
* [[CSC/ECE 517 Fall 2023 - E2369. Reimplement duties controller.rb and badges controller.rb]]
* [[CSC/ECE 517 Fall 2023 - E2370. Reimplement join team requests controller]]
* [[CSC/ECE 517 Fall 2023 - E2371. Reimplement quiz_questionnaires_controller]]
* [[CSC/ECE 517 Fall 2023 - E2373. Reimplementation of teams controller]]
* [[CSC/ECE 517 Fall 2023 - E2374. Reimplement the Question hierarchy]]
* [[CSC/ECE 517 Fall 2023 - E2375. Reimplement Waitlists]]
* [[CSC/ECE 517 Fall 2023 - NTX-2 Observability and Debuggability]]
* [[CSC/ECE 517 Fall 2023 - NTX-4 Extend NDB Operator capabilities to support Postgres HA]]

CSC/ECE 517 Fall 2023-E2360. View for Results of Bidding

2023-11-05T23:54:25Z

Schen76: Blanked the page

CSC/ECE 517 Fall 2023 - E2360. View for Results of Bidding

2023-11-05T23:54:03Z

Schen76: Created page with "== Expertiza == [http://expertiza.ncsu.edu/ Expertiza] is an open source project based on [http://rubyonrails.org/ Ruby on Rails] framework. Expertiza allows the instructor t..."

CSC/ECE 517 Fall 2023

2023-11-05T23:53:46Z

Schen76:

* [[CSC/ECE 517 Fall 2023 - E2358. Refactor student_quizzes_controller.rb]]
* [[CSC/ECE 517 Fall 2023 - E2351. Finish mentor management for assignments without topics]]
* [[CSC/ECE 517 Fall 2023 - E2356. Refactor review_mapping_controller.rb]]
* [[CSC/ECE 517 Fall 2023 - E2359. Refactor user_controller.rb, user.rb, and its child classes]]
* [[CSC/ECE 517 Fall 2023 - E2360. View for Results of Bidding]]
* [[CSC/ECE 517 Fall 2023 - E2367. Reimplement participants_controller.rb, participants.rb and its child classes]]
* [[CSC/ECE 517 Fall 2023 - E2355. Improving Search Facility In Expertiza]]
* [[CSC/ECE 517 Fall 2023 - E2365. Create a user interface for Questionnaire in ReactJS]]
* [[CSC/ECE 517 Fall 2023 - E2364. Create a UI for Course's & Assignment's "Add Participants" page]]
* [[CSC/ECE 517 Fall 2023 - E2361. Create a page to create and update a Questionnaire in ReactJS]]
* [[CSC/ECE 517 Fall 2023 - E2362. Create a page to edit an Assignment's due date in ReactJS]]
* [[CSC/ECE 517 Fall 2023 - E2363. Create a UI for Assignment Edit page "Etc" tab in ReactJS]]
* [[CSC/ECE 517 Fall 2023 - E2375. Reimplement Waitlists]]
* [[CSC/ECE 517 Fall 2023 - E2357. Refactor sign_up_sheet_controller.rb]]
* [[CSC/ECE 517 Fall 2023 - E2366. Reimplement assignment model and assignment controller]]
* [[CSC/ECE 517 Fall 2023 - E2368. Reimplement of due_date.rb]]
* [[CSC/ECE 517 Fall 2023 - E2370. Reimplement join team requests controller]]
* [[CSC/ECE 517 Fall 2023 - E2371. Reimplement quiz_questionnaires_controller]]
* [[CSC/ECE 517 Fall 2023 - E2369. Reimplement duties controller.rb and badges controller.rb]]
* [[CSC/ECE 517 Fall 2023 - E2353. Further refactoring and improvement of review mapping helper]]
* [[CSC/ECE 517 Fall 2023 - E2373. Reimplementation of teams controller]]
* [[CSC/ECE 517 Fall 2023 - E2374. Reimplement the Question hierarchy]]
* [[CSC/ECE 517 Fall 2023 - NTX-2 Observability and Debuggability]]
* [[CSC/ECE 517 Fall 2023 - E2350. Allow reviewers to bid on what to review]]
* [[CSC/ECE 517 Fall 2023 - NTX-4 Extend NDB Operator capabilities to support Postgres HA]]

CSC/ECE 517 Fall 2023-E2360. View for Results of Bidding

2023-11-05T23:51:10Z

File:Rspec testing.png

2023-11-05T23:50:10Z

Schen76:

File:View bidding button.png

2023-11-05T23:47:44Z

Schen76:

File:Bidding details view.png

2023-11-05T23:45:13Z

Schen76:

File:Bidding details controller.png

2023-11-05T23:42:41Z

Schen76:

File:Bidding details.png

2023-11-05T23:16:20Z

Schen76:

File:Bidding button.png

2023-11-05T23:13:17Z

Schen76: