// 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; } }