// GET api/task
public IEnumerable<IParticipantTask> Get()
{
using (CrowdContext db = new CrowdContext())
{
return db.ParticipantTasks.AsEnumerable();
}
}
// GET api/ActivityResult/5
public async Task<HttpResponseMessage> Get(int id)
{
if (id <= 0)
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.BadRequest));
using (CrowdContext db = new CrowdContext())
{
User user = await AuthenticateUser(GetAuthentication(), db);
if (user == null)
{
return new HttpResponseMessage(HttpStatusCode.Unauthorized);
}
var result = db.ParticipantResults.Find(id);
if (result == null)
{
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
}
if (user != result.User)
{
return new HttpResponseMessage(HttpStatusCode.Unauthorized);
}
return new HttpResponseMessage
{
Content = new JsonContent(result)
};
}
}
// GET api/task/5
public async Task<HttpResponseMessage> GetByActivityId(int id)
{
if (id <= 0)
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.BadRequest));
using (CrowdContext db = new CrowdContext())
{
User user = await AuthenticateUser(GetAuthentication(), db);
if (user == null)
{
return new HttpResponseMessage(HttpStatusCode.Unauthorized);
}
var linqResults = from result in db.ParticipantResults
where result.ParticipantActivityId == id && result.User == user
orderby result.Id
select result;
if (linqResults.Any())
{
return new HttpResponseMessage
{
Content = new JsonContent(linqResults)
};
}
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
}
}
public async Task<HttpResponseMessage> Post()
{
using (CrowdContext db = new CrowdContext())
{
User user = await AuthenticateUser(GetAuthentication(), db);
return user == null ? new HttpResponseMessage(HttpStatusCode.Unauthorized)
: new HttpResponseMessage(HttpStatusCode.OK);
}
}
// GET api/Activity
public HttpResponseMessage Get()
{
using (CrowdContext db = new CrowdContext())
{
var acts = db.ParticipantActivities.ToList();
return new HttpResponseMessage()
{
Content = new JsonContent(acts)
};
}
}
/// <summary>
/// Checks if the user has completed an assessment today, returning one if not
/// </summary>
/// <returns></returns>
private static async Task<ParticipantActivity> GetAssessmentIfNeeded(CrowdContext db, User user)
{
bool existing = false;
if (user.LastAssessment != null)
{
ParticipantActivity act = await db.ParticipantActivities.FindAsync(user.LastAssessment.ParticipantActivityId);
if (act != null && act.AppType == user.App) existing = true;
}
if (existing)
{
// We want the user to complete the same assessment each time, at most once a day
ParticipantResult recentUpload = await (from upload in db.ParticipantResults
where upload.User.Email == user.Email &&
upload.IsAssessment &&
((int)upload.ParticipantActivity.AppType == (int)user.App ||
(int)upload.ParticipantActivity.AppType == (int)Crowd.Model.Data.User.AppType.None)
orderby upload.UploadedAt descending
select upload).FirstOrDefaultAsync();
if(recentUpload == null) return null;
TimeSpan span = DateTime.Now - recentUpload.UploadedAt;
if (span.Days >= 1)
{
if (recentUpload.ParticipantActivity != null)
{
return recentUpload.ParticipantActivity;
}
return await db.ParticipantActivities.FindAsync(recentUpload.ParticipantActivityId);
}
}
else
{
// User has yet to complete an assessment - choose a random one
ParticipantActivity[] assessments = await (
from act in db.ParticipantActivities
where act.AssessmentTasks.Count >= 1 &&
((int)act.AppType == (int)user.App ||
(int)act.AppType == (int)Crowd.Model.Data.User.AppType.None)
select act).ToArrayAsync();
if (assessments.Length >= 1)
{
Random rand = new Random();
return assessments[rand.Next(0, assessments.Length - 1)];
}
}
return null;
}
private static async Task<ParticipantActivity> GetRandomScenario(CrowdContext db, User user)
{
ParticipantActivity[] acts = await (from act in db.ParticipantActivities
where (act.AppType == Crowd.Model.Data.User.AppType.None || act.AppType == user.App) &&
act.ParticipantTasks.Count >= 1
select act).ToArrayAsync();
if (acts.Length >= 1)
{
Random rand = new Random();
return acts[rand.Next(0, acts.Length - 1)];
}
return null;
}
public string SayHello()
{
using (var db = new CrowdContext())
{
string ret = "";
//var speechSample = new SpeechingSample { Filename = "xyz.mp3", Description = "test" };
//db.SpeechingSamples.Add(speechSample);
//db.SaveChanges();
//var query = db.SpeechingSamples;
//foreach (var q in query)
// ret += q.Filename + ", ";
return ret;
}
}
// GET api/task/5
public IParticipantTask Get(int id)
{
if (id <= 0)
return new ParticipantTask();
using (CrowdContext db = new CrowdContext())
{
IParticipantTask task = db.ParticipantTasks.Single(c => c.Id.Equals(id));
if (task == null)
{
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
}
return task;
}
}
// GET api/task/5
public IEnumerable<IParticipantTask> GetByActivityId(int id)
{
if (id <= 0)
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
using (CrowdContext db = new CrowdContext())
{
var tasks = db.ParticipantTasks.Where(c => c.ParticipantActivityId.Equals(id));
if (tasks.Any())
{
return tasks;
}
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
}
}
protected async Task<float?> MinimalPairsScore(User user, CrowdContext db, int jobId = -1)
{
try
{
// Get all responses made on these submissions
IQueryable<CrowdRowResponse> allResponses = from crowdResponse in db.CrowdRowResponses
where crowdResponse.ParticipantAssessmentTask != null &&
crowdResponse.ParticipantAssessmentTask.TaskType ==
ParticipantAssessmentTask.AssessmentTaskType.QuickFire &&
crowdResponse.ParticipantResult.User.Email == user.Email &&
((int)crowdResponse.ParticipantResult.ParticipantActivity.AppType == (int)user.App ||
(int)crowdResponse.ParticipantResult.ParticipantActivity.AppType == (int)Crowd.Model.Data.User.AppType.None )
select crowdResponse;
int numResp = await allResponses.CountAsync();
if (numResp <= 0) return null;
int numTotal = await (from crowdResponse in allResponses
from judgement in crowdResponse.TaskJudgements
from data in judgement.Data
where data.DataType == "rlstmp"
select data).CountAsync();
if (numTotal <= 0) return null;
// Get total num of correct judgements
int numCorrect = await (from crowdResponse in allResponses
from judgement in crowdResponse.TaskJudgements
from prompt in db.ParticipantAssessmentTaskPrompts
where prompt.Id.ToString() == crowdResponse.ExtraData
from data in judgement.Data
where data.StringResponse == prompt.Value && data.DataType == "rlstmp"
select data).CountAsync();
float onePercent = numTotal/100f;
return numCorrect/onePercent;
}
catch (Exception)
{
return null;
}
}
// GET api/Activity/5
public HttpResponseMessage Get(int id)
{
if (id <= 0)
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.BadRequest));
using (CrowdContext db = new CrowdContext())
{
var activity = db.ParticipantActivities.Find(id);
if (activity == null)
{
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
}
return new HttpResponseMessage()
{
Content = new JsonContent(activity)
};
}
}
// GET api/Category
public async Task<HttpResponseMessage> Get()
{
using (CrowdContext db = new CrowdContext())
{
User user = await AuthenticateUser(GetAuthentication(), db);
if (user == null)
{
return new HttpResponseMessage(HttpStatusCode.Unauthorized);
}
var defaultCats = await (from category in db.ParticipantActivityCategories
where category.DefaultSubscription &&
(category.App == Crowd.Model.Data.User.AppType.None || category.App == user.App)
select category).ToArrayAsync();
bool changed = false;
foreach (ParticipantActivityCategory category in defaultCats)
{
if (user.SubscribedCategories.Contains(category)) continue;
user.SubscribedCategories.Add(category);
changed = true;
}
if (changed)
{
await db.SaveChangesAsync();
}
for (int i = 0; i < user.SubscribedCategories.Count; i++)
{
user.SubscribedCategories.ElementAt(i).Activities =
(from act in user.SubscribedCategories.ElementAt(i).Activities
where act.AppType == user.App || act.AppType == Crowd.Model.Data.User.AppType.None
select act).ToList();
}
return new HttpResponseMessage()
{
Content = new JsonContent(user.SubscribedCategories)
};
}
}
public async Task<HttpResponseMessage> Get()
{
using (CrowdContext db = new CrowdContext())
{
User user = await AuthenticateUser(GetAuthentication(), db);
if (user == null)
{
return new HttpResponseMessage(HttpStatusCode.Unauthorized);
}
var ordered = await (from assessment in db.ParticipantActivities
where assessment.AssessmentTasks.Count > 0
orderby assessment.DateSet descending
select assessment).ToArrayAsync();
return new HttpResponseMessage
{
Content = new JsonContent(ordered)
};
}
}
public async Task<HttpResponseMessage> Get(string activityType)
{
using (CrowdContext db = new CrowdContext())
{
User user = await AuthenticateUser(GetAuthentication(), db);
if (user == null)
{
return new HttpResponseMessage(HttpStatusCode.Unauthorized);
}
ParticipantAssessmentTask.AssessmentTaskType type;
Enum.TryParse(activityType, true, out type);
ActivityHelper helper = await db.ActivityHelpers.FindAsync(type);
return new HttpResponseMessage()
{
Content = new JsonContent(helper)
};
}
}
// GET api/ActivityResult
public async Task<HttpResponseMessage> Get()
{
using (CrowdContext db = new CrowdContext())
{
User user = await AuthenticateUser(GetAuthentication(), db);
if (user == null)
{
return new HttpResponseMessage(HttpStatusCode.Unauthorized);
}
List<ParticipantResult> lst = await (
from result in db.ParticipantResults
where result.User == user
orderby result.Id
select result).ToListAsync();
return new HttpResponseMessage
{
Content = new JsonContent(lst)
};
}
}
/// <summary>
/// Checks if the given details validate
/// </summary>
/// <param name="auth"></param>
/// <param name="db"></param>
/// <returns>User obj if allowed, otherwise null</returns>
protected async Task<User> AuthenticateUser(AuthenticationModel auth, CrowdContext db)
{
if (auth == null) return null;
User found = await db.Users.FindAsync(auth.Email);
if (found != null && found.Key == auth.Key)
{
User.AppType app;
if (Enum.TryParse(auth.App, true, out app))
{
if (app != found.App)
{
found.App = app;
await db.SaveChangesAsync();
}
}
return found;
}
return null;
}
// DELETE api/task/5
public HttpResponseMessage Delete(int id)
{
if (id <= 0)
return Request.CreateResponse(HttpStatusCode.NotFound, "id must be greater than zero");
using (CrowdContext db = new CrowdContext())
{
var task = db.ParticipantTasks.Single(c => c.Id.Equals(id));
if (task == null)
{
return Request.CreateResponse(HttpStatusCode.NotFound);
}
db.ParticipantTasks.Remove(task);
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException ex)
{
return Request.CreateErrorResponse(HttpStatusCode.NotFound, ex);
}
return Request.CreateResponse(HttpStatusCode.OK, task);
}
}
// GET api/Category/5
public async Task<HttpResponseMessage> Get(int id)
{
using (CrowdContext db = new CrowdContext())
{
User user = await AuthenticateUser(GetAuthentication(), db);
if (user == null)
{
return new HttpResponseMessage(HttpStatusCode.Unauthorized);
}
if (id <= 0)
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.BadRequest));
var category = db.ParticipantActivityCategories.Find(id);
if (category == null)
{
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.BadRequest));
}
return new HttpResponseMessage()
{
Content = new JsonContent(category)
};
}
}
// DELETE api/Activity/5
public HttpResponseMessage Delete(int id)
{
if (id <= 0)
return Request.CreateResponse(HttpStatusCode.NotFound, "id must be greater than zero");
using (CrowdContext db = new CrowdContext())
{
var activity = db.ParticipantActivities.Find(id);
if (activity == null)
{
return Request.CreateResponse(HttpStatusCode.NotFound);
}
db.ParticipantActivities.Remove(activity);
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException ex)
{
return Request.CreateErrorResponse(HttpStatusCode.NotFound, ex);
}
return Request.CreateResponse(HttpStatusCode.OK, activity);
}
}
// DELETE api/Category/5
public async Task<HttpResponseMessage> Delete(int id)
{
using (CrowdContext db = new CrowdContext())
{
User user = await AuthenticateUser(GetAuthentication(), db);
if (user == null)
{
return new HttpResponseMessage(HttpStatusCode.Unauthorized);
}
if (id <= 0)
return Request.CreateResponse(HttpStatusCode.BadRequest, "id must be greater than zero");
var category = db.ParticipantActivityCategories.Find(id);
if (category == null)
{
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.BadRequest));
}
db.ParticipantActivityCategories.Remove(category);
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException ex)
{
return Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex);
}
return Request.CreateResponse(HttpStatusCode.OK, category);
}
}
// DELETE api/ActivityResult/5
public async Task<HttpResponseMessage> Delete(int id)
{
if (id <= 0)
return Request.CreateResponse(HttpStatusCode.BadRequest, "id must be greater than zero");
using (CrowdContext db = new CrowdContext())
{
User user = await AuthenticateUser(GetAuthentication(), db);
if (user == null)
{
return new HttpResponseMessage(HttpStatusCode.Unauthorized);
}
var result = db.ParticipantResults.Find(id);
if (result == null)
{
return Request.CreateResponse(HttpStatusCode.NotFound);
}
if (result.User != user && !user.IsAdmin)
{
return new HttpResponseMessage(HttpStatusCode.Unauthorized);
}
db.ParticipantResults.Remove(result);
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException ex)
{
return Request.CreateErrorResponse(HttpStatusCode.NotFound, ex);
}
return Request.CreateResponse(HttpStatusCode.OK, result);
}
}
public static string CreateCFData(IEnumerable<string> audioPaths, ParticipantActivity activity, ParticipantResult result, out int count)
{
count = 0;
string json = "";
if (!audioPaths.Any())
return json;
using (CrowdContext db = new CrowdContext())
{
result = db.ParticipantResults.Find(result.Id);
CrowdRowResponse[] lastAssessResponses = null;
CrowdRowResponse[] lastNormResponses = null;
int lastAssessTaskId = -1;
int lastNormTaskId = -1;
string extraData = "";
if (result.User.App == User.AppType.Speeching)
{
foreach (var path in audioPaths)
{
string[] options = null;
string taskType = "Other";
CrowdRowResponse comparionResponse = null;
ParticipantResultData thisData = (from data in result.Data
where data.FilePath == Path.GetFileName(path)
select data).FirstOrDefault();
if (thisData == null)
{
continue;
}
int assTaskId = -1;
int normTaskId = -1;
if (thisData.ParticipantAssessmentTask != null) // Is assessment
{
ParticipantAssessmentTask task = thisData.ParticipantAssessmentTask;
assTaskId = task.Id;
List<string> quickFireOptions = new List<string>();
foreach (var prompt in task.PromptCol.Prompts)
{
quickFireOptions.Add(prompt.Value);
}
options = quickFireOptions.ToArray();
switch (task.TaskType)
{
case ParticipantAssessmentTask.AssessmentTaskType.QuickFire:
taskType = "MP";
break;
case ParticipantAssessmentTask.AssessmentTaskType.ImageDesc:
taskType = "Image";
break;
}
string filename = Path.GetFileNameWithoutExtension(path);
string promptId = "";
bool started = false;
// Get the prompt index from the filename
foreach (char c in filename)
{
if (c == '-')
{
started = true;
continue;
}
if (started && char.IsDigit(c))
{
promptId += c;
}
}
if (!string.IsNullOrWhiteSpace(promptId))
{
extraData = promptId;
}
if (lastAssessTaskId != task.Id)
{
lastAssessResponses = (from rowResp in db.CrowdRowResponses
where rowResp.ParticipantAssessmentTaskId == task.Id &&
rowResp.ParticipantResult.User.Key == result.User.Key
orderby rowResp.CreatedAt
select rowResp).ToArray();
lastAssessTaskId = assTaskId;
}
if (lastAssessResponses != null)
{
foreach (CrowdRowResponse resp in lastAssessResponses)
{
// Can't use GetFileName in LINQ expressions so have to do in memory
bool matches = Path.GetFileName(resp.RecordingUrl) == Path.GetFileName(path);
if (!matches) continue;
comparionResponse = resp;
break;
}
}
}
else if (thisData.ParticipantTask != null) // Not assessment
{
normTaskId = thisData.ParticipantTask.Id;
if (lastNormTaskId != normTaskId)
{
lastNormResponses = (from rowResp in db.CrowdRowResponses
where rowResp.ParticipantTaskId == normTaskId &&
rowResp.ParticipantResult.User.Key == result.User.Key
orderby rowResp.CreatedAt
select rowResp).ToArray();
lastNormTaskId = normTaskId;
}
if (lastNormResponses != null)
{
foreach (CrowdRowResponse resp in lastNormResponses)
{
// Can't use GetFileName in LINQ expressions so have to do in memory
bool matches = Path.GetFileName(resp.RecordingUrl) == Path.GetFileName(path);
if (!matches) continue;
comparionResponse = resp;
break;
}
}
}
string choices = "";
string comparisonPath = "";
int prevLoud = -1;
int prevPace = -1;
int prevPitch = -1;
if (options != null)
{
// Shuffle the words
Random rnd = new Random();
options = options.OrderBy(x => rnd.Next()).ToArray();
for (int i = 0; i < options.Length; i++)
{
choices += options[i];
if (i < options.Length - 1) choices += ", ";
}
}
if (comparionResponse != null)
{
comparisonPath = comparionResponse.RecordingUrl;
prevLoud = GetAverageRes(comparionResponse, "rlstvolume");
prevPace = GetAverageRes(comparionResponse, "rlstpace");
prevPitch = GetAverageRes(comparionResponse, "rlstpitch");
}
json += createUnit(path, taskType, assTaskId, normTaskId, choices, prevLoud, prevPace, prevPitch, comparisonPath, extraData);
count += 1;
}
}
else //Fluent
{
json += string.Format("{{\"AudioUrls\":\"{0}\", " +
"\"FeedbackQuery\":\"{1}\"}}\r\n"
, String.Join(",", audioPaths), result.FeedbackQuery);
count += 1;
}
}
json += TestQuestions();
json = json.TrimEnd();
return json;
}
public async Task<HttpResponseMessage> Post(ParticipantResult result)
{
using (CrowdContext db = new CrowdContext())
{
User user = await AuthenticateUser(GetAuthentication(), db);
if (user == null)
{
return new HttpResponseMessage(HttpStatusCode.Unauthorized);
}
if (!ModelState.IsValid) return Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
if (result == null)
return Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Activity result cannot be null");
result.User = user;
result.UploadedAt = DateTime.Now;
result = db.ParticipantResults.Add(result);
user.Submissions.Add(result);
if (result.IsAssessment)
{
user.LastAssessment = result;
}
try
{
db.SaveChanges();
}
catch (Exception ex)
{
return Request.CreateResponse(HttpStatusCode.ExpectationFailed, ex.Message);
}
SvcStatus status = await CrowdFlowerApi.CreateJob(result,
await db.ParticipantActivities.FindAsync(result.ParticipantActivityId));
if (status.Level == 0)
{
string json = await status.Response.Content.ReadAsStringAsync();
CFJobResponse jobRes = JsonConvert.DeserializeObject<CFJobResponse>(json);
result.CrowdJobId = jobRes.id;
if (status.CreatedRows != null)
{
foreach (CrowdRowResponse row in status.CreatedRows)
{
db.CrowdRowResponses.Add(row);
}
}
try
{
db.SaveChanges();
}
catch (Exception e)
{
throw new HttpResponseException(Request.CreateResponse(
HttpStatusCode.ExpectationFailed, e.Message));
}
status = CrowdFlowerApi.LaunchJob(jobRes.id, status.Count);
return status.Response;
}
db.DebugMessages.Add(new DebugMessage
{
Message = status.Description,
Filename = "ActivityResultController",
FunctionName = "Post"
});
await db.SaveChangesAsync();
return Request.CreateErrorResponse(HttpStatusCode.BadRequest, status.Description + " \n\n " + status.Response.ToString());
}
}
// PUT api/ActivityResult/5
public async Task<HttpResponseMessage> Put(int id, ParticipantResult result)
{
if (!ModelState.IsValid)
{
return Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
}
if (id != result.Id)
{
return Request.CreateResponse(HttpStatusCode.BadRequest);
}
using (CrowdContext db = new CrowdContext())
{
User user = await AuthenticateUser(GetAuthentication(), db);
if (user == null || !user.IsAdmin)
{
return new HttpResponseMessage(HttpStatusCode.Unauthorized);
}
db.ParticipantResults.Attach(result);
db.Entry(result).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException ex)
{
return Request.CreateErrorResponse(HttpStatusCode.NotFound, ex);
}
return Request.CreateResponse(HttpStatusCode.OK);
}
}
protected async Task<float?> AverageRating(string resDataType, User user, CrowdContext db, int jobId = -1)
{
try
{
List<int> results;
if (jobId >= 0)
{
results = db.CrowdJudgements.Where(j => j.JobId == jobId)
.SelectMany(j => j.Data.Where(d => d.DataType == resDataType)
.Select(d => d.NumResponse)).ToList();
}
else
{
var jobIds = db.ParticipantResults.Where(res => res.User.Email == user.Email &&
((int)res.ParticipantActivity.AppType == (int)user.App ||
(int)res.ParticipantActivity.AppType == (int)Crowd.Model.Data.User.AppType.None)).Select(r => r.CrowdJobId);
results = db.CrowdJudgements.Where(j => jobIds.Contains(j.JobId))
.Select(j => j.Data.Where(d => d.DataType == resDataType)
.Select(d => d.NumResponse)).SelectMany(r => r).ToList();
}
return SvcUtil.GetMedian(results);
}
catch(Exception)
{
return null;
}
}
protected async Task<TimeGraphPoint[]> GetGraphPoints(string resDataType, User user, CrowdContext db)
{
try
{
CrowdJudgement[] ordered = await (from res in db.ParticipantResults
where res.User.Email == user.Email &&
((int)res.ParticipantActivity.AppType == (int)user.App ||
(int)res.ParticipantActivity.AppType == (int)Crowd.Model.Data.User.AppType.None )
from judgement in db.CrowdJudgements
where res.CrowdJobId == judgement.JobId
orderby judgement.CreatedAt
select judgement).ToArrayAsync();
List<TimeGraphPoint> points = new List<TimeGraphPoint>();
Dictionary<DateTime, List<double>> pointDictionary = new Dictionary<DateTime, List<double>>();
// Group the results by day, so that each day with results will be a point on the graph
foreach (CrowdJudgement judgement in ordered)
{
double yVal = (from data in judgement.Data
where data.DataType == resDataType
select data.NumResponse).Average();
if (pointDictionary.ContainsKey(judgement.CreatedAt.Date))
{
pointDictionary[judgement.CreatedAt.Date].Add(yVal);
}
else
{
pointDictionary.Add(judgement.CreatedAt.Date, new List<double>() { yVal });
}
}
foreach (KeyValuePair<DateTime, List<double>> pair in pointDictionary)
{
points.Add(new TimeGraphPoint
{
XVal = pair.Key,
YVal = pair.Value.Average()
});
}
return points.ToArray();
}
catch(Exception)
{
return null;
}
}
// PUT api/Category/5
public async Task<HttpResponseMessage> Put(ParticipantActivityCategory category)
{
using (CrowdContext db = new CrowdContext())
{
User user = await AuthenticateUser(GetAuthentication(), db);
if (user == null)
{
return new HttpResponseMessage(HttpStatusCode.Unauthorized);
}
if (!ModelState.IsValid)
{
return Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
}
if (category.Id <= 0)
{
return Request.CreateResponse(HttpStatusCode.BadRequest);
}
db.ParticipantActivityCategories.Attach(category);
db.Entry(category).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException ex)
{
return Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex);
}
return Request.CreateResponse(HttpStatusCode.OK);
}
}
protected async Task<ServiceUser> AuthenticateServiceUser(AuthenticationModel auth, CrowdContext db)
{
User rawUser = await AuthenticateUser(auth, db);
return rawUser == null ? null : new ServiceUser(rawUser);
}
// POST api/Category
public async Task<HttpResponseMessage> Post(ParticipantActivityCategory category)
{
using (CrowdContext db = new CrowdContext())
{
User user = await AuthenticateUser(GetAuthentication(), db);
if (user == null)
{
return new HttpResponseMessage(HttpStatusCode.Unauthorized);
}
if (!ModelState.IsValid) return Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
db.ParticipantActivityCategories.Add(category);
db.SaveChanges();
var response = Request.CreateResponse(HttpStatusCode.Created, category);
response.Headers.Location = new Uri(Request.RequestUri.AbsoluteUri + category.Id);//new Uri(Url.Link("DefaultApi", new { id = category.Key }));
return response;
}
}
