public async Task <IActionResult> Post([FromBody] ExerciseItemUserScore score) { if (!ModelState.IsValid) { foreach (var value in ModelState.Values) { foreach (var err in value.Errors) { System.Diagnostics.Debug.WriteLine(err.Exception?.Message); } } return(BadRequest()); } if (score.TakenDate == null) { score.TakenDate = DateTime.Now; } var scorecnt = (from dbscore in this._context.ExerciseItemUserScores where dbscore.User == score.User && dbscore.RefID == score.RefID && dbscore.TakenDate.Value.Date == score.TakenDate.Value.Date select dbscore).Count(); if (scorecnt > 0) { return(BadRequest("Same record exists")); } _context.ExerciseItemUserScores.Add(score); await _context.SaveChangesAsync(); return(Created(score)); }
// POST: /KnowledgeItems /// <summary> /// Support for creating knowledge item /// </summary> public async Task <IActionResult> Post([FromBody] KnowledgeItem knowledge) { if (!ModelState.IsValid) { foreach (var value in ModelState.Values) { foreach (var err in value.Errors) { System.Diagnostics.Debug.WriteLine(err.Exception?.Message); } } return(BadRequest(ModelState)); } String usrId = ControllerUtil.GetUserID(this); if (String.IsNullOrEmpty(usrId)) { return(new UnauthorizedResult()); } knowledge.CreatedAt = DateTime.Now; _context.KnowledgeItems.Add(knowledge); await _context.SaveChangesAsync(); return(Created(knowledge)); }
//// [EnableQuery] //public SingleResult<AwardUser> Get([FromODataUri] String keyTargetUser, String keySupervior) //{ // return SingleResult.Create(_context.AwardUsers.Where(p => p.TargetUser == keyTargetUser && p.Supervisor == keySupervior)); //} // POST: /AwardUsers /// <summary> /// Support for creating award user /// </summary> public async Task <IActionResult> Post([FromODataBody] AwardUser item) { if (!ModelState.IsValid) { foreach (var value in ModelState.Values) { foreach (var err in value.Errors) { System.Diagnostics.Debug.WriteLine(err.Exception?.Message); } } return(BadRequest()); } String usrId = ControllerUtil.GetUserID(this); if (String.IsNullOrEmpty(usrId)) { throw new Exception("Failed ID"); } if (item.Supervisor != usrId) { throw new Exception("Wrong User"); } _context.AwardUsers.Add(item); await _context.SaveChangesAsync(); return(Created(item)); }
// POST: /ExerciseItems /// <summary> /// Support for creating exercise item /// </summary> public async Task <IActionResult> Post([FromBody] ExerciseItem execitem) { if (!ModelState.IsValid) { foreach (var value in ModelState.Values) { foreach (var err in value.Errors) { System.Diagnostics.Debug.WriteLine(err.Exception?.Message); } } return(BadRequest()); } // Admin. fields execitem.CreatedAt = DateTime.Now; execitem.ModifiedAt = null; //if (execitem.Answer != null) //{ // execitem.Answer.ExerciseItem = execitem; //} //ExerciseItemAnswer execawr = null; //if (execitem.Answer != null) //{ // execawr = new ExerciseItemAnswer(); // execawr.Content = execitem.Answer.Content; // execitem.Answer = null; //} if (execitem.Tags.Count > 0) { foreach (var tag in execitem.Tags) { tag.CurrentExerciseItem = execitem; } } // Update db _context.ExerciseItems.Add(execitem); await _context.SaveChangesAsync(); // Answer //if (execawr != null) //{ // execawr.ItemID = execitem.ID; // _context.ExerciseItemAnswers.Add(execawr); // await _context.SaveChangesAsync(); //} return(Created(execitem)); }
// POST: /UserHabitPoints /// <summary> /// Support for creating user habit record /// </summary> public async Task <IActionResult> Post([FromBody] UserHabitPoint point) { if (!ModelState.IsValid) { foreach (var value in ModelState.Values) { foreach (var err in value.Errors) { System.Diagnostics.Debug.WriteLine(err.Exception?.Message); } } return(BadRequest()); } String usrId = ControllerUtil.GetUserID(this); if (String.IsNullOrEmpty(usrId)) { throw new Exception("Failed ID"); } var rst = (from au in _context.AwardUsers where au.TargetUser == point.TargetUser && au.Supervisor == usrId select au).Count(); if (rst != 1) { throw new Exception("Invalid user data"); } // Update db _context.UserHabitPoints.Add(point); try { await _context.SaveChangesAsync(); } catch (Exception exp) { System.Console.WriteLine(exp.Message); throw; } return(Created(point)); }
// POST: /ExerciseItemAnswers /// <summary> /// Support for creating exercise item answer /// </summary> public async Task <IActionResult> Post([FromBody] ExerciseItemAnswer answer) { if (!ModelState.IsValid) { foreach (var value in ModelState.Values) { foreach (var err in value.Errors) { System.Diagnostics.Debug.WriteLine(err.Exception?.Message); } } return(BadRequest()); } _context.ExerciseItemAnswers.Add(answer); await _context.SaveChangesAsync(); return(Created(answer)); }
public async Task <IActionResult> RemoveItemFromCollection([FromBody] ODataActionParameters parameters) { if (!ModelState.IsValid) { foreach (var value in ModelState.Values) { foreach (var err in value.Errors) { System.Diagnostics.Debug.WriteLine(err.Exception?.Message); } } return(BadRequest(ModelState)); } String user = (String)parameters["User"]; String usrId = ControllerUtil.GetUserID(this); if (String.IsNullOrEmpty(usrId) || user != usrId) { throw new Exception("Failed ID"); } int collid = (int)parameters["ID"]; int refid = (int)parameters["RefID"]; TagRefType reftype = (TagRefType)parameters["RefType"]; if (String.IsNullOrEmpty(user) || refid <= 0) { return(BadRequest("Invalid input")); } // Check collection header var collcnt = (from collheader in this._context.UserCollections where collheader.ID == collid && collheader.User == user select collheader.ID).Count(); if (collcnt != 1) { return(BadRequest("Invalid collection")); } // Check existence of item var nitem = _context.UserCollectionItems.SingleOrDefault(p => p.RefType == reftype && p.RefID == refid && p.ID == collid); if (nitem == null) { return(Ok(false)); } _context.UserCollectionItems.Remove(nitem); await _context.SaveChangesAsync(); return(Ok(true)); }
// POST: /AwardRules public async Task <IActionResult> Post([FromBody] AwardRule rule) { if (!ModelState.IsValid) { foreach (var value in ModelState.Values) { foreach (var err in value.Errors) { System.Diagnostics.Debug.WriteLine(err.Exception?.Message); } } return(BadRequest()); } // Update db _context.AwardRules.Add(rule); await _context.SaveChangesAsync(); return(Created(rule)); }
// POST: /KnowledgeItems /// <summary> /// Support for creating knowledge item /// </summary> public async Task <IActionResult> Post([FromBody] KnowledgeItem knowledge) { if (!ModelState.IsValid) { foreach (var value in ModelState.Values) { foreach (var err in value.Errors) { System.Diagnostics.Debug.WriteLine(err.Exception?.Message); } } return(BadRequest()); } knowledge.CreatedAt = DateTime.Now; _context.KnowledgeItems.Add(knowledge); await _context.SaveChangesAsync(); return(Created(knowledge)); }
// POST: /ExerciseItems /// <summary> /// Support for creating exercise item /// </summary> public async Task <IActionResult> Post([FromBody] ExerciseItem execitem) { if (!ModelState.IsValid) { foreach (var value in ModelState.Values) { foreach (var err in value.Errors) { System.Diagnostics.Debug.WriteLine(err.Exception?.Message); } } return(BadRequest(ModelState)); } String usrId = ControllerUtil.GetUserID(this); if (String.IsNullOrEmpty(usrId)) { return(new UnauthorizedResult()); } // Admin. fields execitem.CreatedAt = DateTime.Now; execitem.ModifiedAt = null; if (execitem.Tags.Count > 0) { foreach (var tag in execitem.Tags) { tag.CurrentExerciseItem = execitem; } } // Update db _context.ExerciseItems.Add(execitem); await _context.SaveChangesAsync(); return(Created(execitem)); }
public async Task <IActionResult> Post([FromBody] DailyTrace dt) { if (!ModelState.IsValid) { foreach (var value in ModelState.Values) { foreach (var err in value.Errors) { System.Diagnostics.Debug.WriteLine(err.Exception?.Message); } } return(BadRequest("Invalid model state")); } var cnt = _context.DailyTraces.Where(p => p.TargetUser == dt.TargetUser && p.RecordDate.Date > dt.RecordDate.Date).Count(); if (cnt > 0) { return(BadRequest("Cannot insert a trace on past")); } // Calculate the points List <AwardPoint> points = CalculatePoints(dt); // Update db _context.DailyTraces.Add(dt); if (points.Count > 0) { _context.AwardPoints.AddRange(points); } await _context.SaveChangesAsync(); return(Created(dt)); }
public async Task <IActionResult> Post([FromBody] UserHabitRecord record) { if (!ModelState.IsValid) { foreach (var value in ModelState.Values) { foreach (var err in value.Errors) { System.Diagnostics.Debug.WriteLine(err.Exception?.Message); } } return(BadRequest()); } // Find out the matched rule var habits = (from habit in this._context.UserHabits where habit.ID == record.HabitID select habit).ToList <UserHabit>(); if (habits.Count != 1) { return(BadRequest("Invalid Habit")); } // Date range for checking if (record.RecordDate >= habits[0].ValidTo || record.RecordDate < habits[0].ValidFrom) { return(BadRequest("Invalid time")); } DateTime dtbgn = record.RecordDate; switch (habits[0].Frequency) { case HabitFrequency.Weekly: dtbgn = HabitWeeklyTrace.getDBSelectionDate((DayOfWeek)habits[0].StartDate, record.RecordDate); break; case HabitFrequency.Monthly: dtbgn = HabitMonthlyTrace.getDBSelectionDate(habits[0].StartDate.Value, record.RecordDate); break; case HabitFrequency.Daily: default: dtbgn = record.RecordDate - TimeSpan.FromDays(1); break; } // Basic check on the record itself switch (habits[0].CompleteCategory) { case HabitCompleteCategory.NumberOfCount: { if (record.CompleteFact.GetValueOrDefault() <= 0) { return(BadRequest("Record must provide complete fact")); } var checkrecord = (from dbrecord in _context.UserHabitRecords where dbrecord.RecordDate > record.RecordDate && dbrecord.HabitID == record.HabitID select dbrecord).Count(); if (checkrecord > 0) { return(BadRequest("Record in the past!")); } checkrecord = (from dbrecord in _context.UserHabitRecords where dbrecord.RecordDate == record.RecordDate && dbrecord.HabitID == record.HabitID && dbrecord.SubID == record.SubID select dbrecord).Count(); if (checkrecord > 0) { return(BadRequest("Conflicted Sub ID!")); } } break; case HabitCompleteCategory.NumberOfTimes: default: { var checkrecord = (from dbrecord in _context.UserHabitRecords where dbrecord.RecordDate >= record.RecordDate && dbrecord.HabitID == record.HabitID select dbrecord).Count(); if (checkrecord > 0) { return(BadRequest("Record in the past!")); } } break; } // Find out all rules var rules = (from rule in this._context.UserHabitRules where rule.HabitID == record.HabitID orderby rule.ContinuousRecordFrom ascending select rule).ToList <UserHabitRule>(); if (rules.Count > 0) { } else { return(BadRequest("No rule defined")); } // Find related records var oldrecords = (from dbrecord in _context.UserHabitRecords where dbrecord.HabitID == record.HabitID && dbrecord.RecordDate >= dtbgn && dbrecord.RecordDate <= record.RecordDate select dbrecord).ToList <UserHabitRecord>(); record.ContinuousCount = 1; // Default is 1 // Now calculate the rule and the points switch (habits[0].Frequency) { case HabitFrequency.Weekly: { HabitWeeklyTrace firstWeek = new HabitWeeklyTrace(); HabitWeeklyTrace secondWeek = new HabitWeeklyTrace(); HabitWeeklyTrace.analyzeUserRecord(oldrecords, dtbgn, firstWeek, secondWeek); // First week int?firstweekrule = firstWeek.getRuleID(); int firstweekcontcnt = 0; if (firstweekrule.HasValue) { firstweekcontcnt = firstWeek.getRuleContinuousCount().GetValueOrDefault(); } // Second week int?secondweekrule = secondWeek.getRuleID(); if (firstweekrule.HasValue) { // Start since last week switch (habits[0].CompleteCategory) { case HabitCompleteCategory.NumberOfCount: { int nexistcnt = secondWeek.getNumberOfCount().GetValueOrDefault(); if (secondweekrule.HasValue) { // Already has rule assigned, move the rule ID to new created one var existRecord = secondWeek.getRecordWithRule(); var existDBRecord = _context.UserHabitRecords .SingleOrDefaultAsync(x => x.HabitID == existRecord.HabitID && x.RecordDate == existRecord.RecordDate && x.SubID == existRecord.SubID); record.RuleID = existDBRecord.Result.RuleID; record.ContinuousCount = existDBRecord.Result.ContinuousCount; existDBRecord.Result.RuleID = null; existDBRecord.Result.ContinuousCount = 0; } else { if (nexistcnt + record.CompleteFact.GetValueOrDefault() >= habits[0].CompleteCondition) { // Workout the new rule (maybe) then var ncontcnt = firstweekcontcnt + 1; var ridx = rules.FindIndex(ruleitem => ncontcnt >= ruleitem.ContinuousRecordFrom && ruleitem.ContinuousRecordTo > ncontcnt); if (ridx != -1) { record.ContinuousCount = ncontcnt; record.RuleID = rules[ridx].RuleID; } } } } break; case HabitCompleteCategory.NumberOfTimes: default: { int nexistcnt = secondWeek.getNumberOfTimes(); if (secondweekrule.HasValue) { // Already has rule assigned, move the rule ID to new created one var existRecord = secondWeek.getRecordWithRule(); var existDBRecord = _context.UserHabitRecords .SingleOrDefaultAsync(x => x.HabitID == existRecord.HabitID && x.RecordDate == existRecord.RecordDate && x.SubID == existRecord.SubID); record.RuleID = existDBRecord.Result.RuleID; record.ContinuousCount = existDBRecord.Result.ContinuousCount; existDBRecord.Result.RuleID = null; existDBRecord.Result.ContinuousCount = 0; } else { if (nexistcnt + 1 == habits[0].CompleteCondition) { // Workout the rule then var ncontcnt = firstweekcontcnt + 1; var ridx = rules.FindIndex(ruleitem => ncontcnt >= ruleitem.ContinuousRecordFrom && ruleitem.ContinuousRecordTo > ncontcnt); if (ridx != -1) { record.ContinuousCount = ncontcnt; record.RuleID = rules[ridx].RuleID; } } } } break; } } else { // New start in this week switch (habits[0].CompleteCategory) { case HabitCompleteCategory.NumberOfCount: { int nexistcnt = secondWeek.getNumberOfCount().GetValueOrDefault(); if (secondweekrule.HasValue) { // Already has rule assigned, move the rule ID to new created one var existRecord = secondWeek.getRecordWithRule(); var existDBRecord = _context.UserHabitRecords .SingleOrDefaultAsync(x => x.HabitID == existRecord.HabitID && x.RecordDate == existRecord.RecordDate && x.SubID == existRecord.SubID); record.RuleID = existDBRecord.Result.RuleID; record.ContinuousCount = existDBRecord.Result.ContinuousCount; existDBRecord.Result.RuleID = null; existDBRecord.Result.ContinuousCount = 0; } else { if (nexistcnt + record.CompleteFact.GetValueOrDefault() >= habits[0].CompleteCondition) { // Workout the rule then var ridx = rules.FindIndex(ruleitem => record.ContinuousCount >= ruleitem.ContinuousRecordFrom && record.ContinuousCount < ruleitem.ContinuousRecordTo); if (ridx != -1) { record.RuleID = rules[ridx].RuleID; } } } } break; case HabitCompleteCategory.NumberOfTimes: default: { int nexistcnt = secondWeek.getNumberOfTimes(); if (secondweekrule.HasValue) { // Already has rule assigned, move the rule ID to new created one var existRecord = secondWeek.getRecordWithRule(); var existDBRecord = _context.UserHabitRecords .SingleOrDefaultAsync(x => x.HabitID == existRecord.HabitID && x.RecordDate == existRecord.RecordDate && x.SubID == existRecord.SubID); record.RuleID = existDBRecord.Result.RuleID; record.ContinuousCount = existDBRecord.Result.ContinuousCount; existDBRecord.Result.RuleID = null; existDBRecord.Result.ContinuousCount = 0; } else { if (nexistcnt + 1 == habits[0].CompleteCondition) { // Workout the rule then var ridx = rules.FindIndex(ruleitem => record.ContinuousCount >= ruleitem.ContinuousRecordFrom && record.ContinuousCount < ruleitem.ContinuousRecordTo); if (ridx != -1) { record.RuleID = rules[ridx].RuleID; } } } } break; } } } break; case HabitFrequency.Monthly: { HabitMonthlyTrace firstMonth = new HabitMonthlyTrace(); HabitMonthlyTrace secondMonth = new HabitMonthlyTrace(); HabitMonthlyTrace.analyzeUserRecord(oldrecords, dtbgn, firstMonth, secondMonth); int?firstMonthRule = firstMonth.getRuleID(); int firstMonthContCount = 0; if (firstMonthRule.HasValue) { firstMonthContCount = firstMonth.getRuleContinuousCount().GetValueOrDefault(); } int?secondMonthRule = secondMonth.getRuleID(); if (firstMonthRule.HasValue) { // Start since last month switch (habits[0].CompleteCategory) { case HabitCompleteCategory.NumberOfCount: { int nexistcnt = secondMonth.getNumberOfCount().GetValueOrDefault(); if (secondMonthRule.HasValue) { // Already has rule assigned, move the rule ID to new created one var existRecord = secondMonth.getRecordWithRule(); var existDBRecord = _context.UserHabitRecords .SingleOrDefaultAsync(x => x.HabitID == existRecord.HabitID && x.RecordDate == existRecord.RecordDate && x.SubID == existRecord.SubID); record.RuleID = existDBRecord.Result.RuleID; record.ContinuousCount = existDBRecord.Result.ContinuousCount; existDBRecord.Result.RuleID = null; existDBRecord.Result.ContinuousCount = 0; } else { if (nexistcnt + record.CompleteFact.GetValueOrDefault() >= habits[0].CompleteCondition) { // Workout the new rule (maybe) then var ncontcnt = firstMonthContCount + 1; var ridx = rules.FindIndex(ruleitem => ncontcnt >= ruleitem.ContinuousRecordFrom && ruleitem.ContinuousRecordTo > ncontcnt); if (ridx != -1) { record.ContinuousCount = ncontcnt; record.RuleID = rules[ridx].RuleID; } else { record.ContinuousCount = firstMonthContCount; } } else { record.ContinuousCount = firstMonthContCount; } } } break; case HabitCompleteCategory.NumberOfTimes: default: { int nexistcnt = secondMonth.getNumberOfTimes(); if (secondMonthRule.HasValue) { // Already has rule assigned, move the rule ID to new created one var existRecord = secondMonth.getRecordWithRule(); var existDBRecord = _context.UserHabitRecords .SingleOrDefaultAsync(x => x.HabitID == existRecord.HabitID && x.RecordDate == existRecord.RecordDate && x.SubID == existRecord.SubID); record.RuleID = existDBRecord.Result.RuleID; record.ContinuousCount = existDBRecord.Result.ContinuousCount; existDBRecord.Result.RuleID = null; existDBRecord.Result.ContinuousCount = 0; } else { if (nexistcnt + 1 == habits[0].CompleteCondition) { // Workout the rule then var ncontcnt = firstMonthContCount + 1; var ridx = rules.FindIndex(ruleitem => ncontcnt >= ruleitem.ContinuousRecordFrom && ruleitem.ContinuousRecordTo > ncontcnt); if (ridx != -1) { record.ContinuousCount = ncontcnt; record.RuleID = rules[ridx].RuleID; } } } } break; } } else { // New start in this month switch (habits[0].CompleteCategory) { case HabitCompleteCategory.NumberOfCount: { int nexistcnt = secondMonth.getNumberOfCount().GetValueOrDefault(); if (secondMonthRule.HasValue) { // Already has rule assigned, move the rule ID to new created one var existRecord = secondMonth.getRecordWithRule(); var existDBRecord = _context.UserHabitRecords .SingleOrDefaultAsync(x => x.HabitID == existRecord.HabitID && x.RecordDate == existRecord.RecordDate && x.SubID == existRecord.SubID); record.RuleID = existDBRecord.Result.RuleID; record.ContinuousCount = existDBRecord.Result.ContinuousCount; existDBRecord.Result.RuleID = null; existDBRecord.Result.ContinuousCount = 0; } else { if (nexistcnt + record.CompleteFact.GetValueOrDefault() >= habits[0].CompleteCondition) { // Workout the rule then var ridx = rules.FindIndex(ruleitem => record.ContinuousCount >= ruleitem.ContinuousRecordFrom && record.ContinuousCount < ruleitem.ContinuousRecordTo); if (ridx != -1) { record.RuleID = rules[ridx].RuleID; } } } } break; case HabitCompleteCategory.NumberOfTimes: default: { int nexistcnt = secondMonth.getNumberOfTimes(); if (secondMonthRule.HasValue) { // Already has rule assigned, move the rule ID to new created one var existRecord = secondMonth.getRecordWithRule(); var existDBRecord = _context.UserHabitRecords .SingleOrDefaultAsync(x => x.HabitID == existRecord.HabitID && x.RecordDate == existRecord.RecordDate && x.SubID == existRecord.SubID); record.RuleID = existDBRecord.Result.RuleID; record.ContinuousCount = existDBRecord.Result.ContinuousCount; existDBRecord.Result.RuleID = null; existDBRecord.Result.ContinuousCount = 0; } else { if (nexistcnt + 1 == habits[0].CompleteCondition) { // Workout the rule then var ridx = rules.FindIndex(ruleitem => record.ContinuousCount >= ruleitem.ContinuousRecordFrom && record.ContinuousCount < ruleitem.ContinuousRecordTo); if (ridx != -1) { record.RuleID = rules[ridx].RuleID; } else { record.ContinuousCount = 0; } } else { record.ContinuousCount = 0; } } } break; } } } break; case HabitFrequency.Daily: default: { HabitDailyTrace yesterday = new HabitDailyTrace(); HabitDailyTrace today = new HabitDailyTrace(); HabitDailyTrace.analyzeUserRecord(oldrecords, dtbgn, yesterday, today); int?yesterdayrule = yesterday.getRuleID(); int yesterdaycontcnt = 0; if (yesterdayrule.HasValue) { yesterdaycontcnt = yesterday.getRuleContinuousCount().GetValueOrDefault(); } int?todayrule = today.getRuleID(); if (yesterdayrule.HasValue) { switch (habits[0].CompleteCategory) { case HabitCompleteCategory.NumberOfCount: { int nexistcnt = today.getNumberOfCount().GetValueOrDefault(); if (todayrule.HasValue) { // Already has rule assigned, move the rule ID to new created one var existRecord = today.getRecordWithRule(); var existDBRecord = _context.UserHabitRecords .SingleOrDefaultAsync(x => x.HabitID == existRecord.HabitID && x.RecordDate == existRecord.RecordDate && x.SubID == existRecord.SubID); record.RuleID = existDBRecord.Result.RuleID; record.ContinuousCount = existDBRecord.Result.ContinuousCount; existDBRecord.Result.RuleID = null; existDBRecord.Result.ContinuousCount = 0; } else { if (nexistcnt + record.CompleteFact.GetValueOrDefault() >= habits[0].CompleteCondition) { // Workout the new rule (maybe) then var ncontcnt = yesterdaycontcnt + 1; var ridx = rules.FindIndex(ruleitem => ncontcnt >= ruleitem.ContinuousRecordFrom && ruleitem.ContinuousRecordTo > ncontcnt); if (ridx != -1) { record.ContinuousCount = ncontcnt; record.RuleID = rules[ridx].RuleID; } } else { record.ContinuousCount = 0; } } } break; case HabitCompleteCategory.NumberOfTimes: default: { int nexistcnt = today.getNumberOfTimes(); if (todayrule.HasValue) { // Shall never happen throw new Exception("Unexpected"); } else { // Workout the rule then var ncontcnt = yesterdaycontcnt + 1; var ridx = rules.FindIndex(ruleitem => ncontcnt >= ruleitem.ContinuousRecordFrom && ruleitem.ContinuousRecordTo > ncontcnt); if (ridx != -1) { record.ContinuousCount = ncontcnt; record.RuleID = rules[ridx].RuleID; } else { record.ContinuousCount = 0; } } } break; } } else { var ncontcnt = yesterdaycontcnt + 1; // New start of the day switch (habits[0].CompleteCategory) { case HabitCompleteCategory.NumberOfCount: { int completedFact = today.getNumberOfCount().GetValueOrDefault(); completedFact += record.CompleteFact.GetValueOrDefault(); if (completedFact >= habits[0].CompleteCondition) { var ridx = rules.FindIndex(ruleitem => ncontcnt >= ruleitem.ContinuousRecordFrom && ruleitem.ContinuousRecordTo > ncontcnt); if (ridx != -1) { record.ContinuousCount = ncontcnt; record.RuleID = rules[ridx].RuleID; } } else { record.ContinuousCount = 0; } } break; case HabitCompleteCategory.NumberOfTimes: default: { // Workout the rule then var ridx = rules.FindIndex(ruleitem => ncontcnt >= ruleitem.ContinuousRecordFrom && ruleitem.ContinuousRecordTo > ncontcnt); if (ridx != -1) { record.ContinuousCount = ncontcnt; record.RuleID = rules[ridx].RuleID; } else { record.ContinuousCount = 0; } } break; } } } break; } // Update db _context.UserHabitRecords.Add(record); try { await _context.SaveChangesAsync(); } catch (Exception exp) { System.Console.WriteLine(exp.Message); throw; } return(Created(record)); }
// POST: /UserHabits /// <summary> /// Support for creating user habit /// </summary> public async Task <IActionResult> Post([FromBody] UserHabit habit) { if (!ModelState.IsValid) { foreach (var value in ModelState.Values) { foreach (var err in value.Errors) { System.Diagnostics.Debug.WriteLine(err.Exception?.Message); } } return(BadRequest()); } String usrId = ControllerUtil.GetUserID(this); if (String.IsNullOrEmpty(usrId)) { throw new Exception("Failed ID"); } // Check 0. User var ucnt = _context.AwardUsers.Where(p => p.TargetUser == habit.TargetUser && p.Supervisor == usrId).Count(); if (ucnt != 1) { return(BadRequest("Invalid user")); } // Check 1. Validity if (habit.ValidTo <= habit.ValidFrom) { return(BadRequest("Invalid Validity")); } switch (habit.Frequency) { case HabitFrequency.Weekly: if (!habit.StartDate.HasValue) { return(BadRequest("Invalid start date")); } else { try { DayOfWeek dow = (DayOfWeek)habit.StartDate.Value; if (!Enum.IsDefined(typeof(DayOfWeek), dow)) { throw new Exception("Invalid start date"); } } catch (Exception exp) { return(BadRequest(exp.Message)); } switch (habit.CompleteCategory) { case HabitCompleteCategory.NumberOfCount: if (habit.CompleteCondition <= 0) { return(BadRequest("Invalid done criteria")); } break; case HabitCompleteCategory.NumberOfTimes: default: if (habit.CompleteCondition > 7 || habit.CompleteCondition <= 0) { return(BadRequest("Invalid done criteria")); } break; } } break; case HabitFrequency.Monthly: if (!habit.StartDate.HasValue) { return(BadRequest("Invalid start date")); } else { if (habit.StartDate.Value > 28 || habit.StartDate < 1) { return(BadRequest("Invalid start date")); } switch (habit.CompleteCategory) { case HabitCompleteCategory.NumberOfCount: if (habit.CompleteCondition <= 0) { return(BadRequest("Invalid done criteria")); } break; case HabitCompleteCategory.NumberOfTimes: default: if (habit.CompleteCondition > 28 || habit.CompleteCondition <= 0) { return(BadRequest("Invalid done criteria")); } break; } } break; case HabitFrequency.Daily: default: if (habit.StartDate.HasValue) { return(BadRequest("Invalid start date")); } switch (habit.CompleteCategory) { case HabitCompleteCategory.NumberOfCount: if (habit.CompleteCondition <= 0) { return(BadRequest("Invalid done criteria")); } break; case HabitCompleteCategory.NumberOfTimes: default: if (habit.CompleteCondition != 1) { return(BadRequest("Invalid done criteria")); } break; } break; } // Check 2. Rules if (habit.Rules.Count < 0) { return(BadRequest("Habit must define with rules")); } // habit.Rules.Sort(prop => prop.); int i = 1; foreach (var rule in habit.Rules) { rule.RuleID = i++; rule.CurrentHabit = habit; } // Update db _context.UserHabits.Add(habit); await _context.SaveChangesAsync(); return(Created(habit)); }