/// <summary>
/// Creates a Group as a new entry in the DB.
/// </summary>
/// <param name="group">Group object to add to the DB.</param>
/// <returns>ID of the created Group on success, 0 on failure.</returns>
public static int CreateNewGroup(Group group)
{
try
{
using (SqlConnection connection = ConnectionManager.GetConnection())
{
var data = new ActivEarthDataProvidersDataContext(connection);
var groupData = new GroupDataProvider
{
name = group.Name,
description = group.Description,
owner_id = group.Owner.UserID,
green_score = group.GreenScore,
badge_score = group.ActivityScore.BadgeScore,
challenge_score = group.ActivityScore.ChallengeScore,
contest_score = group.ActivityScore.ContestScore,
};
data.GroupDataProviders.InsertOnSubmit(groupData);
data.SubmitChanges();
foreach (User member in group.Members) {
GroupMemberDataProvider memberData = new GroupMemberDataProvider
{
user_id = member.UserID,
group_id = groupData.id
};
data.GroupMemberDataProviders.InsertOnSubmit(memberData);
}
foreach (string tag in group.HashTags)
{
GroupHashtagDataProvider hashtagData = new GroupHashtagDataProvider
{
hashtag = tag,
group_id = groupData.id
};
data.GroupHashtagDataProviders.InsertOnSubmit(hashtagData);
}
data.SubmitChanges();
data.Connection.Close();
return groupData.id;
}
}
catch (Exception)
{
return 0;
}
}
/// <summary>
/// Saves a privacy setting as a new entry in the DB.
/// </summary>
/// <param name="privacySetting">Privacy setting object to add to the DB.</param>
/// <returns>ID of the created privacy setting on success, 0 on failure.</returns>
public static int CreateNewPrivacySetting(PrivacySetting privacySetting)
{
try
{
int id;
using (SqlConnection connection = ConnectionManager.GetConnection())
{
var data = new ActivEarthDataProvidersDataContext(connection);
var privacySettingData = new PrivacySettingDataProvider
{
id = privacySetting.ID,
email = privacySetting.Email,
gender = privacySetting.Gender,
age = privacySetting.Age,
height = privacySetting.Height,
weight = privacySetting.Weight,
profile_visibility = (Byte)privacySetting.ProfileVisibility,
user_id = privacySetting.UserID
};
data.PrivacySettingDataProviders.InsertOnSubmit(privacySettingData);
data.SubmitChanges();
id = privacySettingData.id;
}
return id;
}
catch (Exception)
{
return 0;
}
}
/// <summary>
/// Creates a new DB entry for a team member.
/// </summary>
/// <param name="teamMember">Member to be added to the DB.</param>
/// <param name="teamId">Team ID that the member should be added to.</param>
/// <returns>ID of the newly added Team Member entry on success, 0 on failure.</returns>
public static int CreateNewTeamMember(ContestTeamMember teamMember, int teamId)
{
try
{
int contestId = TeamDAO.GetContestIdFromTeamId(teamId);
using (SqlConnection connection = ConnectionManager.GetConnection())
{
if (TeamDAO.UserCompetingInContest(teamMember.UserId, contestId)) { throw new Exception("User is already competing in the contest"); }
var data = new ActivEarthDataProvidersDataContext(connection);
var userData = new TeamMemberDataProvider
{
contest_id = contestId,
team_id = teamId,
user_id = teamMember.UserId,
score = teamMember.Score,
initialized = teamMember.Initialized,
initial_score = teamMember.InitialScore
};
data.TeamMemberDataProviders.InsertOnSubmit(userData);
data.SubmitChanges();
return userData.id;
}
}
catch (Exception)
{
return 0;
}
}
/// <summary>
/// Saves a Team as a new entry in the DB.
/// </summary>
/// <param name="team">Team object to add to the DB.</param>
/// <returns>ID of the created team on success, 0 on failure.</returns>
public static int CreateNewTeam(Team team, int contestId)
{
try
{
int id;
using (SqlConnection connection = ConnectionManager.GetConnection())
{
var data = new ActivEarthDataProvidersDataContext(connection);
var teamData = new TeamDataProvider
{
name = team.Name,
score = team.Score,
contest_id = contestId
};
data.TeamDataProviders.InsertOnSubmit(teamData);
data.SubmitChanges();
id = teamData.id;
}
UpdateTeamMembers(team);
return id;
}
catch (Exception)
{
return 0;
}
}
/// <summary>
/// Adds a new Carpool to the database.
/// </summary>
/// <param name="carpool">Carpool to add to the database.</param>
/// <returns>Primary Key (ID) of the newly added Carpool.</returns>
public static int AddCarpool(Carpool carpool, out string errorMessage)
{
try
{
using (SqlConnection connection = ConnectionManager.GetConnection())
{
errorMessage = String.Empty;
var data = new ActivEarthDataProvidersDataContext(connection);
var carpoolData = new CarpoolDataProvider
{
start = carpool.Start,
destination = carpool.Destination,
time = carpool.Time,
seats_available = carpool.SeatsAvailable,
comments = carpool.Comments,
user_id = carpool.UserId
};
data.CarpoolDataProviders.InsertOnSubmit(carpoolData);
data.SubmitChanges();
return carpoolData.id;
}
}
catch (Exception e)
{
errorMessage = e.Message;
return 0;
}
}
/// <summary>
/// Saves a challenge as a new entry in the DB.
/// </summary>
/// <param name="challenge">Challenge object to add to the DB.</param>
/// <returns>ID of the created challenge on success, 0 on failure.</returns>
public static int CreateNewChallenge(Challenge challenge)
{
try
{
using (SqlConnection connection = ConnectionManager.GetConnection())
{
var data = new ActivEarthDataProvidersDataContext(connection);
var challengeData = new ChallengeDataProvider
{
name = challenge.Name,
description = challenge.Description,
reward = challenge.Reward,
requirement = challenge.Requirement,
persistent = challenge.IsPersistent,
end_time = challenge.EndTime,
duration_days = challenge.Duration.Days,
statistic = (byte)challenge.StatisticBinding,
active = challenge.IsActive,
image_path = challenge.ImagePath
};
data.ChallengeDataProviders.InsertOnSubmit(challengeData);
data.SubmitChanges();
return challengeData.id;
}
}
catch (Exception)
{
return 0;
}
}
/// <summary>
/// Saves a Team as a new entry in the DB.
/// </summary>
/// <param name="team">Team object to add to the DB.</param>
/// <returns>ID of the created team on success, 0 on failure.</returns>
public static int CreateNewTeam(ContestTeam team)
{
try
{
int id;
using (SqlConnection connection = ConnectionManager.GetConnection())
{
var data = new ActivEarthDataProvidersDataContext(connection);
var teamData = new TeamDataProvider
{
name = team.Name,
score = team.Score,
contest_id = team.ContestId,
locked = team.IsLocked,
group_id = team.GroupId,
bracket = team.Bracket
};
data.TeamDataProviders.InsertOnSubmit(teamData);
data.SubmitChanges();
id = teamData.id;
}
TeamDAO.UpdateTeamMembers(team);
return id;
}
catch (Exception)
{
return 0;
}
}
/// <summary>
/// Saves a user statistic as a new entry in the DB.
/// </summary>
/// <param name="userId">User to create stat for.</param>
/// <param name="statType">Statistic type to create.</param>
/// <param name="val">Value of the statistic.</param>
/// <returns>ID of the created statistic on success, 0 on failure.</returns>
public static int CreateNewStatisticForUser(int userId, Statistic statType, float val)
{
try
{
int id;
using (SqlConnection connection = ConnectionManager.GetConnection())
{
var data = new ActivEarthDataProvidersDataContext(connection);
var statisticData = new UserStatisticDataProvider
{
user_id = userId,
value = val,
statistic_type = (byte)statType
};
data.UserStatisticDataProviders.InsertOnSubmit(statisticData);
data.SubmitChanges();
id = statisticData.id;
}
return id;
}
catch (Exception)
{
return 0;
}
}
/// <summary>
/// Adds a new Route to the database.
/// </summary>
/// <param name="route">Route to add to the database.</param>
/// <returns>Primary Key (ID) of the newly added Route.</returns>
public static int AddNewRoute(Route route, out string errorMessage)
{
try
{
using (SqlConnection connection = ConnectionManager.GetConnection())
{
errorMessage = String.Empty;
var data = new ActivEarthDataProvidersDataContext(connection);
var routeData = new ActiveRouteDataProvider
{
gmt_offset = route.GMTOffset,
distance = route.Distance,
end_latitude = route.EndLatitude,
end_longitude = route.EndLongitude,
end_time = route.EndTime,
mode = route.Mode,
points = route.Points,
start_latitude = route.StartLatitude,
start_longitude = route.StartLongitude,
start_time = route.StartTime,
steps = route.Steps,
type = route.Type,
user_id = route.UserId
};
data.ActiveRouteDataProviders.InsertOnSubmit(routeData);
data.SubmitChanges();
if (routeData.id > 0)
{
ActiveRouteDAO.ProcessRoute(route);
}
return routeData.id;
}
}
catch (Exception e)
{
errorMessage = e.Message;
return 0;
}
}
public static bool CreateNewUser(User user, string password)
{
try
{
using (SqlConnection connection = ConnectionManager.GetConnection())
{
var data = new ActivEarthDataProvidersDataContext(connection);
var userData = new UserDataProvider {password = password, user_name = user.UserName,};
data.UserDataProviders.InsertOnSubmit(userData);
data.SubmitChanges();
return true;
}
}
catch (Exception)
{
return false;
}
}
/// <summary>
/// Adds a new Recycle Center to the database.
/// </summary>
/// <param name="center">Recycle Center to add to the database.</param>
/// <returns>Primary Key (ID) of the newly added Recycle Center.</returns>
public static int AddRecycleCenter(RecycleCenter center, out string errorMessage)
{
try
{
using (SqlConnection connection = ConnectionManager.GetConnection())
{
errorMessage = String.Empty;
var data = new ActivEarthDataProvidersDataContext(connection);
var centerData = new RecyclingCenterDataProvider
{
location = center.Location,
comments = center.Comments,
automotive = center.Automotive,
electronics = center.Electronics,
construction = center.Construction,
batteries = center.Batteries,
garden = center.Garden,
glass = center.Glass,
hazardous = center.Hazardous,
household = center.Household,
metal = center.Metal,
paint = center.Paint,
paper = center.Paper,
plastic = center.Plastic,
user_id = center.UserId
};
data.RecyclingCenterDataProviders.InsertOnSubmit(centerData);
data.SubmitChanges();
return centerData.id;
}
}
catch (Exception e)
{
errorMessage = e.Message;
return 0;
}
}
/// <summary>
/// Saves a contest as a new entry in the DB.
/// </summary>
/// <param name="contest">Contest object to add to the DB.</param>
/// <returns>ID of the created contest on success, 0 on failure.</returns>
public static int CreateNewContest(Contest contest)
{
try
{
int id;
using (SqlConnection connection = ConnectionManager.GetConnection())
{
var data = new ActivEarthDataProvidersDataContext(connection);
var contestData = new ContestDataProvider
{
name = contest.Name,
description = contest.Description,
points = contest.Points,
end_mode = (byte)contest.Mode,
end_goal = contest.EndCondition.EndValue,
end_time = contest.EndCondition.EndTime,
start = contest.StartTime,
type = (byte)contest.Type,
statistic = (byte)contest.StatisticBinding,
};
data.ContestDataProviders.InsertOnSubmit(contestData);
data.SubmitChanges();
id = contestData.id;
}
foreach (Team team in contest.Teams)
{
//TeamDAO.CreateNewTeam(team, contest.ID);
}
return id;
}
catch (Exception)
{
return 0;
}
}
/// <summary>
/// Creates a new user initialization entry for a challenge.
/// </summary>
/// <param name="challengeId">ID of the challenge the user is participating in.</param>
/// <param name="userId">ID of the user being initialized.</param>
/// <param name="value">Current value of the relevant statistic for the challenge.</param>
/// <returns></returns>
public static bool CreateInitializationEntry(int challengeId, int userId, float value)
{
try
{
using (SqlConnection connection = ConnectionManager.GetConnection())
{
var data = new ActivEarthDataProvidersDataContext(connection);
var challengeData = new ChallengeInitializationDataProvider
{
challenge_id = challengeId,
user_id = userId,
value = value
};
data.ChallengeInitializationDataProviders.InsertOnSubmit(challengeData);
data.SubmitChanges();
return (challengeData.id > 0);
}
}
catch (Exception)
{
return false;
}
}
/// <summary>
/// Saves a badge as a new entry in the DB.
/// </summary>
/// <param name="badge">Badge object to add to the DB.</param>
/// <returns>ID of the created badge on success, 0 on failure.</returns>
public static int CreateNewBadge(Badge badge)
{
try
{
using (SqlConnection connection = ConnectionManager.GetConnection())
{
var data = new ActivEarthDataProvidersDataContext(connection);
var badgeData = new BadgeDataProvider
{
user_id = badge.UserID,
badge_level = (byte)badge.Level,
progress = (byte)badge.Progress,
statistic = (byte)badge.StatisticBinding
};
data.BadgeDataProviders.InsertOnSubmit(badgeData);
data.SubmitChanges();
return badgeData.id;
}
}
catch (Exception)
{
return 0;
}
}
/// <summary>
/// Creates a new DB entry for a team member.
/// </summary>
/// <param name="teamMember">Member to be added to the DB.</param>
/// <param name="teamId">Team ID that the member should be added to.</param>
/// <returns>ID of the newly added Team Member entry on success, 0 on failure.</returns>
public static int CreateNewTeamMember(TeamMember teamMember, int teamId)
{
try
{
using (SqlConnection connection = ConnectionManager.GetConnection())
{
var data = new ActivEarthDataProvidersDataContext(connection);
var userData = new TeamMemberDataProvider
{
team_id = (int)teamId,
user_id = (int)teamMember.User.UserID,
initialized = teamMember.Initialized,
initial_score = teamMember.InitialScore
};
data.TeamMemberDataProviders.InsertOnSubmit(userData);
data.SubmitChanges();
return userData.id;
}
}
catch (Exception)
{
return 0;
}
}
/// <summary>
/// Updates an existing Contest in the DB.
/// </summary>
/// <param name="contest">Contest whose record needs updating.</param>
/// <returns>True on success, false on failure.</returns>
public static bool UpdateContest(Contest contest)
{
try
{
using (SqlConnection connection = ConnectionManager.GetConnection())
{
var data = new ActivEarthDataProvidersDataContext(connection);
ContestDataProvider dbContest =
(from c in data.ContestDataProviders where c.id == contest.ID select c).FirstOrDefault();
if (dbContest != null)
{
dbContest.name = contest.Name;
dbContest.description = contest.Description;
dbContest.reward = contest.Reward;
dbContest.end_mode = (byte)contest.Mode;
dbContest.end_goal = contest.EndValue;
dbContest.end_time = contest.EndTime;
dbContest.start = contest.StartTime;
dbContest.type = (byte)contest.Type;
dbContest.statistic = (byte)contest.StatisticBinding;
dbContest.searchable = contest.IsSearchable;
dbContest.active = contest.IsActive;
dbContest.deactivated = contest.DeactivatedTime;
dbContest.creator_id = contest.CreatorId;
data.SubmitChanges();
}
else
{
return false;
}
}
if (contest != null)
{
foreach (ContestTeam team in contest.Teams)
{
TeamDAO.UpdateTeam(team);
}
}
return true;
}
catch (Exception)
{
return false;
}
}
/// <summary>
/// Removes contests from the DB that have were deactivated more than two weeks ago.
/// </summary>
/// <returns></returns>
public static bool RemoveOldContests()
{
int daysToExpire = 14;
try
{
using (SqlConnection connection = ConnectionManager.GetConnection())
{
var data = new ActivEarthDataProvidersDataContext(connection);
List<ContestDataProvider> dbContests =
(from c in data.ContestDataProviders
where
(c.deactivated != null &&
c.deactivated.Value.Subtract(DateTime.Now) > new TimeSpan(daysToExpire, 0, 0, 0))
select c).ToList();
foreach (ContestDataProvider dbContest in dbContests)
{
data.ContestDataProviders.DeleteOnSubmit(dbContest);
data.SubmitChanges();
}
return true;
}
}
catch (Exception)
{
return false;
}
}
/// <summary>
/// Deletes an existing Contest from the DB.
/// </summary>
/// <param name="contestId">ID for the Contest whose record needs to be removed.</param>
/// <returns>True on success (or the contest didn't exist), false on failure.</returns>
public static bool RemoveContestFromContestId(int contestId)
{
try
{
using (SqlConnection connection = ConnectionManager.GetConnection())
{
var data = new ActivEarthDataProvidersDataContext(connection);
ContestDataProvider dbContest =
(from c in data.ContestDataProviders where c.id == contestId select c).FirstOrDefault();
if (dbContest != null)
{
data.ContestDataProviders.DeleteOnSubmit(dbContest);
data.SubmitChanges();
}
return true;
}
}
catch (Exception)
{
return false;
}
}
/// <summary>
/// Updates a Group's the list of Recent Acitivity Messages in the Database.
/// </summary>
/// <param name="group">The Group for which to update Recent Activity Messages</param>
public static bool UpdateGroupRecentActivity(Group group)
{
int groupId = group.ID;
try
{
using (SqlConnection connection = ConnectionManager.GetConnection())
{
var data = new ActivEarthDataProvidersDataContext(connection);
List<MessageDataProvider> messages = (from m in data.MessageDataProviders
where m.group_id == groupId
select
m
).ToList();
foreach (MessageDataProvider messageData in messages)
{
bool found = false;
foreach (Message message in group.Wall.Messages)
{
if (messageData.message == message.Text && messageData.user_id == message.Poster.UserID
&& messageData.title == message.Title && messageData.time == message.Time && messageData.date == message.Date)
{
found = true;
}
}
if (!found)
{
data.MessageDataProviders.DeleteOnSubmit(messageData);
}
}
foreach (Message message in group.Wall.Messages)
{
bool found = false;
foreach (MessageDataProvider messageData in messages)
{
if (messageData.message == message.Text && messageData.user_id == message.Poster.UserID
&& messageData.title == message.Title && messageData.time == message.Time && messageData.date == message.Date)
{
found = true;
}
}
if (!found)
{
MessageDataProvider messageData = new MessageDataProvider
{
title = message.Title,
message = message.Text,
user_id = message.Poster.UserID,
group_id = groupId,
date = message.Date,
time = message.Time
};
data.MessageDataProviders.InsertOnSubmit(messageData);
}
}
data.SubmitChanges();
return true;
}
}
catch(Exception)
{
return false;
}
}
/// <summary>
/// Updates the entry of any members already existing on the team, and creates
/// new entries for new members of the team.
/// </summary>
/// <param name="team">Team whose members must be updated.</param>
/// <returns>True on success, false on failure.</returns>
public static bool UpdateTeamMembers(ContestTeam team)
{
try
{
foreach (ContestTeamMember user in team.Members)
{
using (SqlConnection connection = ConnectionManager.GetConnection())
{
var data = new ActivEarthDataProvidersDataContext(connection);
var dbUser =
(from u in data.TeamMemberDataProviders
where u.team_id == team.ID && u.user_id == user.UserId
select u).FirstOrDefault();
if (dbUser != null)
{
dbUser.score = user.Score;
dbUser.initial_score = user.InitialScore;
dbUser.initialized = user.Initialized;
data.SubmitChanges();
}
else
{
if (CreateNewTeamMember(user, team.ID) == 0)
{
return false;
}
}
}
}
return true;
}
catch (Exception)
{
return false;
}
}
/// <summary>
/// Removes all team member entries pertaining to a given team.
/// </summary>
/// <param name="teamId">Team to remove the members from.</param>
/// <returns>True on success, false on failure.</returns>
public static bool RemoveTeamMembersFromTeamId(int teamId)
{
try
{
using (SqlConnection connection = ConnectionManager.GetConnection())
{
var data = new ActivEarthDataProvidersDataContext(connection);
var members = (from c in data.TeamMemberDataProviders
where c.team_id == teamId
select c).ToList();
foreach (TeamMemberDataProvider member in members)
{
data.TeamMemberDataProviders.DeleteOnSubmit(member);
data.SubmitChanges();
}
return true;
}
}
catch (Exception)
{
return false;
}
}
/// <summary>
/// Updates an existing PrivacySetting in the DB.
/// </summary>
/// <param name="privacySetting">PrivacySetting whose record needs updating.</param>
/// <returns>True on success, false on failure.</returns>
public static bool UpdatePrivacySetting(PrivacySetting privacySetting)
{
try
{
using (SqlConnection connection = ConnectionManager.GetConnection())
{
var data = new ActivEarthDataProvidersDataContext(connection);
PrivacySettingDataProvider dbPrivacySetting =
(from p in data.PrivacySettingDataProviders where p.id == privacySetting.ID select p).FirstOrDefault();
if (dbPrivacySetting != null)
{
dbPrivacySetting.email = privacySetting.Email;
dbPrivacySetting.gender = privacySetting.Gender;
dbPrivacySetting.age = privacySetting.Age;
dbPrivacySetting.height = privacySetting.Height;
dbPrivacySetting.weight = privacySetting.Weight;
dbPrivacySetting.profile_visibility = (Byte)privacySetting.ProfileVisibility;
data.SubmitChanges();
}
else
{
return false;
}
}
return true;
}
catch (Exception)
{
return false;
}
}
/// <summary>
/// Deletes an existing PrivacySetting from the DB.
/// </summary>
/// <param name="privacySettingId">ID for the PrivacySetting whose record needs to be removed.</param>
/// <returns>True on success (or the privacy setting didn't exist), false on failure.</returns>
public static bool RemovePrivacySettingFromPrivacySettingId(int privacySettingId)
{
try
{
using (SqlConnection connection = ConnectionManager.GetConnection())
{
var data = new ActivEarthDataProvidersDataContext(connection);
PrivacySettingDataProvider dbPrivacySetting =
(from p in data.PrivacySettingDataProviders where p.id == privacySettingId select p).FirstOrDefault();
if (dbPrivacySetting != null)
{
data.PrivacySettingDataProviders.DeleteOnSubmit(dbPrivacySetting);
data.SubmitChanges();
}
return true;
}
}
catch (Exception)
{
return false;
}
}
/// <summary>
/// Removes an existing Team from the DB.
/// </summary>
/// <param name="team">Team to remove.</param>
/// <returns>True on success, false on failure.</returns>
public static bool RemoveTeam(int teamId)
{
try
{
TeamDAO.RemoveTeamMembersFromTeamId(teamId);
using (SqlConnection connection = ConnectionManager.GetConnection())
{
var data = new ActivEarthDataProvidersDataContext(connection);
TeamDataProvider dbTeam =
(from c in data.TeamDataProviders where c.id == teamId select c).FirstOrDefault();
if (dbTeam != null)
{
data.TeamDataProviders.DeleteOnSubmit(dbTeam);
data.SubmitChanges();
}
return true;
}
}
catch (Exception)
{
return false;
}
}
/// <summary>
/// Removes a team member DB entry.
/// </summary>
/// <param name="userId">User to remove.</param>
/// <param name="contestId">Contest to remove the user from.</param>
/// <returns>True on success, false on failure.</returns>
public static bool RemoveTeamMemberFromUserIdAndContestId(int userId, int contestId)
{
try
{
using (SqlConnection connection = ConnectionManager.GetConnection())
{
var data = new ActivEarthDataProvidersDataContext(connection);
var member = (from c in data.TeamMemberDataProviders
where c.user_id == userId && c.contest_id == contestId
select c).FirstOrDefault();
if (member != null)
{
data.TeamMemberDataProviders.DeleteOnSubmit(member);
data.SubmitChanges();
return true;
}
else
{
return false;
}
}
}
catch (Exception)
{
return false;
}
}
public static bool UpdateUserProfile(User user)
{
try
{
using (SqlConnection connection = ConnectionManager.GetConnection())
{
var data = new ActivEarthDataProvidersDataContext(connection);
ProfileDataProvider profile =
(from p in data.ProfileDataProviders where p.user_id == user.UserID select p).FirstOrDefault();
if (profile != null)
{
profile.first_name = user.FirstName;
profile.last_name = user.LastName;
profile.gender = user.Gender;
profile.city = user.City;
profile.state = user.State;
profile.email = user.Email;
profile.age = user.Age;
profile.height = user.Height;
profile.weight = user.Weight;
data.SubmitChanges();
return true;
}
else
{
return false;
}
}
}
catch (Exception)
{
return false;
}
}
/// <summary>
/// Updates an existing Team in the DB.
/// </summary>
/// <param name="team">Team whose record needs updating.</param>
/// <returns>True on success, false on failure.</returns>
public static bool UpdateTeam(ContestTeam team)
{
try
{
using (SqlConnection connection = ConnectionManager.GetConnection())
{
var data = new ActivEarthDataProvidersDataContext(connection);
TeamDataProvider dbTeam =
(from c in data.TeamDataProviders where c.id == team.ID select c).FirstOrDefault();
if (dbTeam != null)
{
dbTeam.name = team.Name;
dbTeam.score = team.Score;
dbTeam.locked = team.IsLocked;
dbTeam.group_id = team.GroupId;
dbTeam.contest_id = team.ContestId;
dbTeam.bracket = team.Bracket;
data.SubmitChanges();
UpdateTeamMembers(team);
return true;
}
else
{
CreateNewTeam(team);
return true;
}
}
}
catch (Exception)
{
return false;
}
}
/// <summary>
/// Saves a contest as a new entry in the DB.
/// </summary>
/// <param name="contest">Contest object to add to the DB.</param>
/// <returns>ID of the created contest on success, 0 on failure.</returns>
public static int CreateNewContest(Contest contest)
{
try
{
int id;
using (SqlConnection connection = ConnectionManager.GetConnection())
{
var data = new ActivEarthDataProvidersDataContext(connection);
var contestData = new ContestDataProvider
{
name = contest.Name,
description = contest.Description,
reward = contest.Reward,
end_mode = (byte)contest.Mode,
end_goal = contest.EndValue,
end_time = contest.EndTime,
start = contest.StartTime,
type = (byte)contest.Type,
statistic = (byte)contest.StatisticBinding,
searchable = contest.IsSearchable,
active = contest.IsActive,
deactivated = contest.DeactivatedTime,
creator_id = contest.CreatorId
};
data.ContestDataProviders.InsertOnSubmit(contestData);
data.SubmitChanges();
id = contestData.id;
}
foreach (ContestTeam team in contest.Teams)
{
TeamDAO.CreateNewTeam(team);
}
return id;
}
catch (Exception)
{
return 0;
}
}
public static bool UpdatePassword(string password, int userId)
{
try
{
using (SqlConnection connection = ConnectionManager.GetConnection())
{
var data = new ActivEarthDataProvidersDataContext(connection);
var user = (from u in data.UserDataProviders
where u.id == userId
select u).FirstOrDefault();
if (user != null)
{
user.password = password;
data.SubmitChanges();
return true;
}
return false;
}
}
catch (Exception)
{
return false;
}
}
/// <summary>
/// Updates an existing Challenge in the DB.
/// </summary>
/// <param name="challenge">Challenge whose record needs updating.</param>
/// <returns>True on success, false on failure.</returns>
public static bool UpdateChallenge(Challenge challenge)
{
try
{
using (SqlConnection connection = ConnectionManager.GetConnection())
{
var data = new ActivEarthDataProvidersDataContext(connection);
ChallengeDataProvider dbChallenge =
(from c in data.ChallengeDataProviders where c.id == challenge.ID select c).FirstOrDefault();
if (dbChallenge != null)
{
dbChallenge.name = challenge.Name;
dbChallenge.description = challenge.Description;
dbChallenge.reward = challenge.Reward;
dbChallenge.requirement = challenge.Requirement;
dbChallenge.persistent = challenge.IsPersistent;
dbChallenge.end_time = challenge.EndTime;
dbChallenge.duration_days = challenge.Duration.Days;
dbChallenge.statistic = (byte)challenge.StatisticBinding;
dbChallenge.active = challenge.IsActive;
dbChallenge.image_path = challenge.ImagePath;
data.SubmitChanges();
return true;
}
else
{
return false;
}
}
}
catch (Exception)
{
return false;
}
}
