//// [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));
}
// DELETE: /AwardUsers(5)
/// <summary>
/// Support for deleting award user gorup
/// </summary>
public async Task <IActionResult> Delete([FromODataUri] String keyTargetUser, [FromODataUri] String keySupervior)
{
var usr = await _context.AwardUsers.FindAsync(keyTargetUser, keySupervior);
if (usr == null)
{
return(NotFound());
}
String usrId = ControllerUtil.GetUserID(this);
if (String.IsNullOrEmpty(usrId))
{
throw new Exception("Failed ID");
}
if (usr.Supervisor != usrId)
{
throw new Exception("Invalid User");
}
_context.AwardUsers.Remove(usr);
await _context.SaveChangesAsync();
return(StatusCode(204)); // HttpStatusCode.NoContent
}
// 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));
}
// PUT: /KnowledgeItems(5)
/// <summary>
/// Support for updating Knowledge items
/// </summary>
public async Task <IActionResult> Put([FromODataUri] int key, [FromBody] KnowledgeItem update)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (key != update.ID)
{
return(NotFound());
}
String usrId = ControllerUtil.GetUserID(this);
if (String.IsNullOrEmpty(usrId))
{
return(new UnauthorizedResult());
}
var isexist = await _context.KnowledgeItems.Where(p => p.ID == key).CountAsync();
if (isexist <= 0)
{
return(NotFound());
}
update.ModifiedAt = DateTime.Now;
_context.Entry(update).State = EntityState.Modified;
//knowitem.UpdateData(update);
var tagsindb = _context.KnowledgeTags.Where(p => p.RefID == update.ID).AsNoTracking().ToList();
foreach (var ditem in update.Tags)
{
var itemindb = tagsindb.Find(p => p.TagTerm == ditem.TagTerm);
if (itemindb == null)
{
_context.KnowledgeTags.Add(ditem);
}
}
foreach (var ditem in tagsindb)
{
var nitem = update.Tags.FirstOrDefault(p => p.TagTerm == ditem.TagTerm);
if (nitem == null)
{
_context.KnowledgeTags.Remove(ditem);
}
}
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
throw;
}
return(Updated(update));
}
public IQueryable <UserHabitRecordView> Get()
{
String usrId = ControllerUtil.GetUserID(this);
if (String.IsNullOrEmpty(usrId))
{
throw new Exception("Failed ID");
}
return(from vdata in _context.UserHabitRecordViews
join auser in _context.AwardUsers
on vdata.TargetUser equals auser.TargetUser
where auser.Supervisor == usrId
select vdata);
//var resultInterms = from record in _context.UserHabitRecords
// join habit in _context.UserHabits
// on record.HabitID equals habit.ID
// join auser in _context.AwardUsers
// on habit.TargetUser equals auser.TargetUser
// where auser.Supervisor == usrId
// select new
// {
// HabitID = record.HabitID,
// Comment = record.Comment,
// CompleteFact = record.CompleteFact,
// RecordDate = record.RecordDate,
// ContinuousCount = record.ContinuousCount,
// RuleID = record.RuleID,
// SubID = record.SubID,
// TargetUser = habit.TargetUser,
// HabitName = habit.Name,
// HabitValidFrom = habit.ValidFrom,
// HabitValidTo = habit.ValidTo
// };
//var results = from intrst in resultInterms
// join rule in _context.UserHabitRules
// on new { HabitID = intrst.HabitID, RuleID = intrst.RuleID.GetValueOrDefault() } equals new { HabitID = rule.HabitID, RuleID = rule.RuleID }
// into ps
// from p in ps.DefaultIfEmpty()
// select new UserHabitRecordView
// {
// HabitID = intrst.HabitID,
// Comment = intrst.Comment,
// CompleteFact = intrst.CompleteFact,
// RecordDate = intrst.RecordDate,
// ContinuousCount = intrst.ContinuousCount,
// RuleID = intrst.RuleID,
// SubID = intrst.SubID,
// TargetUser = intrst.TargetUser,
// HabitName = intrst.HabitName,
// HabitValidFrom = intrst.HabitValidFrom,
// HabitValidTo = intrst.HabitValidTo,
// RuleDaysFrom = p.ContinuousRecordFrom,
// RuleDaysTo = p.ContinuousRecordTo,
// RulePoint = p.Point,
// };
//return results;
}
// DELETE: UserHabitPoints(id)
public async Task <IActionResult> Delete([FromODataUri] int key)
{
var point = await _context.UserHabitPoints.FindAsync(key);
if (point == null)
{
return(NotFound());
}
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");
}
_context.UserHabitPoints.Remove(point);
await _context.SaveChangesAsync();
return(StatusCode(204)); // HttpStatusCode.NoContent
}
public IQueryable <AwardUserView> Get()
{
String usrId = ControllerUtil.GetUserID(this);
if (String.IsNullOrEmpty(usrId))
{
throw new Exception("Failed ID");
}
return(_context.AwardUserViews.Where(p => p.Supervisor == usrId));
}
public SingleResult <UserCollection> Get([FromODataUri] int key)
{
String usrId = ControllerUtil.GetUserID(this);
if (String.IsNullOrEmpty(usrId))
{
throw new UnauthorizedAccessException("Failed ID");
}
return(SingleResult.Create(_context.UserCollections.Where(p => p.User == usrId && p.ID == key)));
}
public IQueryable <UserCollection> Get()
{
String usrId = ControllerUtil.GetUserID(this);
if (String.IsNullOrEmpty(usrId))
{
throw new UnauthorizedAccessException("Failed ID");
}
return(_context.UserCollections.Where(p => p.User == usrId));
}
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));
}
public IQueryable <UserHabitPointReport> Get()
{
String usrId = ControllerUtil.GetUserID(this);
if (String.IsNullOrEmpty(usrId))
{
throw new Exception("Failed ID");
}
return(from report in this._context.UserHabitPointReports
join auser in _context.AwardUsers
on report.TargetUser equals auser.TargetUser
where auser.Supervisor == usrId // || auser.TargetUser == usrId
select report);
}
public SingleResult <UserHabit> Get([FromODataUri] int key)
{
String usrId = ControllerUtil.GetUserID(this);
if (String.IsNullOrEmpty(usrId))
{
throw new Exception("Failed ID");
}
return(SingleResult.Create(from habit in _context.UserHabits
join auser in _context.AwardUsers
on habit.TargetUser equals auser.TargetUser
where auser.Supervisor == usrId && habit.ID == key
select habit));
}
public IQueryable <UserHabitPointsByUserDate> Get()
{
String usrId = ControllerUtil.GetUserID(this);
if (String.IsNullOrEmpty(usrId))
{
throw new Exception("Failed ID");
}
return(from point in _context.UserHabitPointsByUserDates
join auser in _context.AwardUsers
on point.TargetUser equals auser.TargetUser
where auser.Supervisor == usrId
select point);
}
public IQueryable <UserHabitRecord> Get()
{
String usrId = ControllerUtil.GetUserID(this);
if (String.IsNullOrEmpty(usrId))
{
throw new Exception("Failed ID");
}
return(from record in _context.UserHabitRecords
join habit in _context.UserHabits
on new { record.HabitID } equals new { HabitID = habit.ID }
join auser in _context.AwardUsers
on new { habit.TargetUser } equals new { auser.TargetUser }
where auser.Supervisor == usrId
select record);
}
public IActionResult GetOpeningPoint([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());
}
String usrId = ControllerUtil.GetUserID(this);
if (String.IsNullOrEmpty(usrId))
{
throw new Exception("Failed ID");
}
String user = (String)parameters["User"];
Int32 daysBackTo = (Int32)parameters["DaysBackTo"];
DateTime dt = DateTime.Now;
TimeSpan ts = new TimeSpan(daysBackTo, 0, 0, 0);
dt = dt.Subtract(ts);
var rst = (from au in _context.AwardUsers
where au.TargetUser == user &&
au.Supervisor == usrId
select au).Count();
if (rst != 1)
{
throw new Exception("Invalid user data");
}
var point = (from usrpoint in this._context.UserHabitPointsByUserDates
where usrpoint.TargetUser == user && usrpoint.RecordDate < dt
select usrpoint.Point).Sum();
return(Ok(point));
}
// 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));
}
public SingleResult <UserHabitRecord> Get([FromODataUri] Int32 keyHabitID, [FromODataUri] DateTime keyRecordDate, [FromODataUri] Int32 keySubID)
{
String usrId = ControllerUtil.GetUserID(this);
if (String.IsNullOrEmpty(usrId))
{
throw new Exception("Failed ID");
}
return(SingleResult.Create(
from record in _context.UserHabitRecords
join habit in _context.UserHabits
on new { record.HabitID } equals new { HabitID = habit.ID }
join auser in _context.AwardUsers
on new { habit.TargetUser } equals new { auser.TargetUser }
where auser.Supervisor == usrId && record.HabitID == keyHabitID && record.RecordDate == keyRecordDate && record.SubID == keySubID
select record));
}
public IQueryable <InvitedUser> Get()
{
String usrName = String.Empty;
try
{
usrName = ControllerUtil.GetUserID(this);
if (String.IsNullOrEmpty(usrName))
{
throw new UnauthorizedAccessException();
}
}
catch
{
throw new UnauthorizedAccessException();
}
return(_context.InvitedUsers.Where(p => p.UserID == usrName));
}
// PATCH: /ExerciseItems
/// <summary>
/// Support for partial updates of knowledge items
/// </summary>
public async Task <IActionResult> Patch([FromODataUri] int key, [FromBody] Delta <ExerciseItem> execitem)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
String usrId = ControllerUtil.GetUserID(this);
if (String.IsNullOrEmpty(usrId))
{
return(new UnauthorizedResult());
}
var entity = await _context.ExerciseItems.FindAsync(key);
if (entity == null)
{
return(NotFound());
}
execitem.Patch(entity);
entity.ModifiedAt = DateTime.Now;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!_context.ExerciseItems.Any(p => p.ID == key))
{
return(NotFound());
}
else
{
throw;
}
}
return(Updated(entity));
}
// DELETE: /KnowledgeItems(5)
/// <summary>
/// Support for deleting knowledge item by key.
/// </summary>
public async Task <IActionResult> Delete([FromODataUri] int key)
{
var knowledge = await _context.KnowledgeItems.FindAsync(key);
if (knowledge == null)
{
return(NotFound());
}
String usrId = ControllerUtil.GetUserID(this);
if (String.IsNullOrEmpty(usrId))
{
return(new UnauthorizedResult());
}
_context.KnowledgeItems.Remove(knowledge);
await _context.SaveChangesAsync();
return(StatusCode(204)); // HttpStatusCode.NoContent
}
// 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 <ActionResult> Delete([FromODataUri] int key)
{
String usrId = ControllerUtil.GetUserID(this);
if (String.IsNullOrEmpty(usrId))
{
throw new Exception("Failed ID");
}
// Check whether the habit already in using
var recordcnt = _context.UserHabitRecords.Where(p => p.HabitID == key).Count();
if (recordcnt > 0)
{
return(BadRequest("Habit is in using"));
}
var habititem = await _context.UserHabits.FindAsync(key);
if (habititem == null)
{
return(NotFound());
}
var ucnt = _context.AwardUsers.Where(p => p.TargetUser == habititem.TargetUser && p.Supervisor == usrId).Count();
if (ucnt != 1)
{
return(BadRequest("Invalid user"));
}
_context.UserHabits.Remove(habititem);
await _context.SaveChangesAsync();
return(StatusCode(204)); // HttpStatusCode.NoContent
}
public async Task <IActionResult> AddItemToCollectionEx([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"];
if (String.IsNullOrEmpty(user))
{
return(BadRequest("Invalid input"));
}
String usrId = ControllerUtil.GetUserID(this);
if (String.IsNullOrEmpty(usrId) || user != usrId)
{
throw new Exception("Failed ID");
}
var items = (IEnumerable <UserCollectionItem>)parameters["UserCollectionItems"];
foreach (var item in items)
{
if (item != null)
{
if (item.CreatedAt == null)
{
item.CreatedAt = DateTime.Today;
}
// Check collection header
var collcnt = (from collheader in this._context.UserCollections
where collheader.ID == item.ID && collheader.User == user
select collheader.ID).Count();
if (collcnt != 1)
{
return(BadRequest("Invalid collection"));
}
// Check existence of item
var itemcnt = (from collitem in this._context.UserCollectionItems
where collitem.RefType == item.RefType && collitem.RefID == item.RefID && collitem.ID == item.ID
select collitem.ID).Count();
if (itemcnt > 0)
{
return(NoContent());
}
// Check existence of ref. id
switch (item.RefType)
{
case TagRefType.KnowledgeItem:
break;
case TagRefType.ExerciseItem:
default:
{
var refcnt = (from exec in _context.ExerciseItems
where exec.ID == item.RefID
select exec.ID).Count();
if (refcnt != 1)
{
return(BadRequest("Invalid refence ID"));
}
}
break;
}
var nitem = new UserCollectionItem(item);
this._context.UserCollectionItems.Add(nitem);
}
}
await this._context.SaveChangesAsync();
return(Ok(items));
}
// PUT: /ExerciseItems/5
/// <summary>
/// Support for updating exercise items
/// </summary>
public async Task <IActionResult> Put([FromODataUri] int key, [FromBody] ExerciseItem update)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (key != update.ID)
{
return(BadRequest("Key is not matched"));
}
String usrId = ControllerUtil.GetUserID(this);
if (String.IsNullOrEmpty(usrId))
{
return(new UnauthorizedResult());
}
var isexist = await _context.ExerciseItems.Where(p => p.ID == key).CountAsync();
if (isexist <= 0)
{
return(NotFound());
}
// Update itself
update.ModifiedAt = DateTime.Now;
_context.Entry(update).State = EntityState.Modified;
// Tags
var tagsindb = _context.ExerciseTags.Where(p => p.RefID == update.ID).AsNoTracking().ToList();
foreach (var ditem in update.Tags)
{
var itemindb = tagsindb.Find(p => p.TagTerm == ditem.TagTerm);
if (itemindb == null)
{
_context.ExerciseTags.Add(ditem);
}
}
foreach (var ditem in tagsindb)
{
var nitem = update.Tags.FirstOrDefault(p => p.TagTerm == ditem.TagTerm);
if (nitem == null)
{
_context.ExerciseTags.Remove(ditem);
}
}
// Answer
var answerindb = _context.ExerciseItemAnswers.Where(p => p.ID == update.ID).AsNoTracking().FirstOrDefault();
if (answerindb == null)
{
// Not exist
if (update.Answer != null)
{
// Insert
_context.ExerciseItemAnswers.Add(update.Answer);
}
}
else
{
// Already in DB
if (update.Answer != null)
{
// Insert
_context.Entry(update.Answer).State = EntityState.Modified;
}
else
{
_context.ExerciseItemAnswers.Remove(answerindb);
}
}
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
throw;
}
return(Updated(update));
}
// 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));
}
public async Task <IActionResult> AddItemToCollection([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"];
var createAtValue = parameters["CreatedAt"];
DateTime? createdAt = null;
if (createAtValue != null)
{
createdAt = ((DateTimeOffset)createAtValue).DateTime;
}
else
{
createdAt = DateTime.Today;
}
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 itemcnt = (from collitem in this._context.UserCollectionItems
where collitem.RefType == reftype && collitem.RefID == refid && collitem.ID == collid
select collitem.ID).Count();
if (itemcnt > 0)
{
return(NoContent());
}
// Check existence of ref. id
switch (reftype)
{
case TagRefType.KnowledgeItem:
break;
case TagRefType.ExerciseItem:
default:
{
var refcnt = (from exec in _context.ExerciseItems
where exec.ID == refid
select exec.ID).Count();
if (refcnt != 1)
{
return(BadRequest("Invalid refence ID"));
}
}
break;
}
var nitem = new UserCollectionItem();
nitem.ID = collid;
nitem.RefID = refid;
nitem.RefType = reftype;
nitem.CreatedAt = createdAt;
this._context.UserCollectionItems.Add(nitem);
await this._context.SaveChangesAsync();
return(Ok(nitem));
}
// PUT: /UserCollections(5)
/// <summary>
/// Support for updating user collection
/// </summary>
public async Task <IActionResult> Put([FromODataUri] int key, [FromBody] UserCollection update)
{
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));
}
if (key != update.ID)
{
return(BadRequest("Invalid key"));
}
String usrId = ControllerUtil.GetUserID(this);
if (String.IsNullOrEmpty(usrId) || update.User != usrId)
{
return(new UnauthorizedResult());
}
// Check existes
var isexist = await _context.UserCollections.AsNoTracking().Where(p => p.ID == key).CountAsync();
if (isexist <= 0)
{
return(NotFound());
}
update.ModifiedAt = DateTime.Now;
_context.Entry(update).State = EntityState.Modified;
// Items
var itemsindb = _context.UserCollectionItems.AsNoTracking().Where(p => p.ID == update.ID).ToList();
foreach (var ditem in update.Items)
{
var itemindb = itemsindb.Find(p => p.RefType == ditem.RefType && p.RefID == ditem.RefID);
if (itemindb == null)
{
_context.UserCollectionItems.Add(ditem);
}
}
foreach (var ditem2 in itemsindb)
{
var nitem = update.Items.FirstOrDefault(p => p.RefType == ditem2.RefType && p.RefID == ditem2.RefID);
if (nitem == null)
{
_context.UserCollectionItems.Remove(ditem2);
}
}
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
throw;
}
return(Ok(update));
}
