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