public HttpResponseMessage<CourseEvent> AddCourseEvent(CourseEvent courseevent)
{
// Add the region that was passed in as the argument
context.CourseEvents.Add(courseevent);
context.SaveChanges();
// Prepare the response - we want to return "201 Created"
HttpResponseMessage<CourseEvent> response = new HttpResponseMessage<CourseEvent>(courseevent, HttpStatusCode.Created);
return response;
}
private void CreateStudentEvent(int studentId, DateTime dateEvent, string description, int createById, int assignToId, int courseId)
{
CourseEvent courseEvent = new CourseEvent(courseId, studentId);
courseEvent.AssignToId = assignToId;
courseEvent.Date = dateEvent;
courseEvent.Description = description;
courseEvent.Status = (int)CourseState.PLANNED;
//TODO : save to db
}
public async Task <IEnumerable <CourseEvent> > GetCoureEventsAsync(Guid courseEventsId)
{
var args = new Dictionary <string, object>()
{
{ Constants.CourseEventsPage.RequestParameters.CourseEventId, courseEventsId }
};
var requestUri = BuildUriRequestString(Constants.CourseEventsPage.Uri, args);
HttpResponseMessage response = await httpClient.GetAsync(requestUri);
EnsureResponseCompletedSuccessfully(response);
return(CourseEvent.ListFromHttpContent(response.Content));
}
public Course Parse(string text)
{
var course = new Course();
course.CourseEvents = new List <CourseEvent>();
var regex = @"Assignment \b\d due:";
var rg = new Regex(regex);
var m1 = rg.Match(text);
if (m1.Success)
{
var courseEvent = new CourseEvent();
var evtDateStr = text.Substring(m1.Index + m1.Length, 20);
var t = "";
var i = m1.Index + m1.Length;
var dtFound = false;
var monthNameEnd = text.IndexOf(" ", m1.Index + m1.Length + 1);
var monthName = text.Substring(m1.Index + m1.Length, monthNameEnd - m1.Index - m1.Length);
var day = text.Substring(monthNameEnd + 1, 2);
if (!Char.IsDigit(day[1]))
{
day = text.Substring(monthNameEnd, 1);
}
courseEvent.Description = text.Substring(m1.Index, m1.Length);
var monthInd = DateTime.ParseExact(monthName.Trim(), "MMMM", CultureInfo.CurrentCulture).Month;
courseEvent.Date = new DateTime(2020, monthInd, int.Parse(day));
course.CourseEvents.Add(courseEvent);
}
return(course);
}
public async Task CreateEventAsync(string userId, CreateInputModel inputModel)
{
var newEvent = new Event
{
Name = inputModel.Name,
Date = DateTime.ParseExact(inputModel.Date, "dd-MM-yyyy", CultureInfo.InvariantCulture),
CourseId = inputModel.CourseId,
UserId = userId,
};
var mapping = new CourseEvent
{
CourseId = newEvent.CourseId,
EventId = newEvent.Id,
};
await this.mapTableRepository.AddAsync(mapping);
await this.eventRepository.AddAsync(newEvent);
await this.eventRepository.SaveChangesAsync();
await this.mapTableRepository.SaveChangesAsync();
}
public async Task <IHttpActionResult> GetEnrollment([FromUri] int courseId, int?courseEventId, [FromBody] FilterUserModel request)
{
Course course = await db.Courses
.FirstOrDefaultAsync(x => x.Id == courseId);
if (course == null)
{
return(BadRequest());
}
CourseEvent courseEvent = new CourseEvent();
var users = new List <User>();
if (course.Status == CourseStatus.Trial)
{
courseEvent = await db.CourseEvents.FirstOrDefaultAsync(x => x.CourseId == course.Id &&
x.Status == CourseEventStatus.Trial);
}
if (course.Status == CourseStatus.Published)
{
if (courseEventId != null)
{
courseEvent = await db.CourseEvents.FirstOrDefaultAsync(x => x.Id == courseEventId.Value);
}
else
{
courseEvent = await db.CourseEvents.Where(x => x.CourseId == courseId).OrderByDescending(x => x.CreatedDate)
.FirstOrDefaultAsync();
}
}
if (courseEvent != null)
{
users = db.Enrollments
.Include(x => x.Learner)
.Where(x => x.CourseEventId == courseEvent.Id && x.Status == EnrollmentStatus.Enrolled)
.Select(x => x.Learner.User).ToList();
}
else
{
return(BadRequest());
}
if (users == null)
{
return(NotFound());
}
var totalCount = users.Count();
//advance search
var query = users.Where(s => (request.Name == null || s.Name.Contains(request.Name)) &&
(request.Email == null || s.Email.Contains(request.Email)) &&
(request.UserType == null || s.UserType == request.UserType)
);
//quick search
if (!string.IsNullOrEmpty(request.search.value))
{
var value = request.search.value.Trim();
query = query.Where(p => p.Name.Contains(value) ||
p.Email.Contains(value)
);
}
var filteredCount = query.Count();
if (request.order != null)
{
string sortBy = request.columns[request.order[0].column].data;
bool sortAscending = request.order[0].dir.ToLower() == "asc";
switch (sortBy)
{
case "Name":
if (sortAscending)
{
query = query.OrderBy(o => o.Name);
}
else
{
query = query.OrderByDescending(o => o.Name);
}
break;
case "UserType":
if (sortAscending)
{
query = query.OrderBy(o => o.UserType);
}
else
{
query = query.OrderByDescending(o => o.UserType);
}
break;
case "Email":
if (sortAscending)
{
query = query.OrderBy(o => o.Email);
}
else
{
query = query.OrderByDescending(o => o.Email);
}
break;
default:
query = query.OrderByDescending(o => o.Name);
break;
}
}
else
{
query = query.OrderByDescending(o => o.Name);
}
var data = query.Skip(request.start).Take(request.length)
.Select(s => new UserModel
{
Id = s.Id,
Name = s.Name,
Email = s.Email,
UserType = s.UserType
}).ToList();
data.ForEach(item => { item.UserTypeDesc = item.UserType.GetDisplayName(); });
return(Ok(new DataTableResponse
{
draw = request.draw,
recordsTotal = totalCount,
recordsFiltered = filteredCount,
data = data.ToArray()
}));
}
public async Task <IHttpActionResult> StartTrial(int id, int createdBy)
{
var entity = await db.Courses
.Include(x => x.CourseApprovalLog)
.FirstOrDefaultAsync(x => x.Id == id);
if (entity == null)
{
return(BadRequest());
}
if (entity.Status == CourseStatus.Trial)
{
return(BadRequest("The course is already in trial mode."));
}
try
{
if (entity.Status == CourseStatus.Draft)
{
entity.Status = CourseStatus.Trial;
db.SetModified(entity);
var newEvent = new CourseEvent
{
Name = "Trial Event",
CourseId = entity.Id,
Status = CourseEventStatus.Trial,
Start = DateTime.Now,
EnrollmentCode = $"TRIAL({entity.Code}-{DateTime.Now.Ticks})",
ViewCategory = ViewCategory.Private,
CreatedBy = createdBy,
IsTrial = true
};
db.CourseEvents.Add(newEvent);
await db.SaveChangesAsync();
if (entity.CourseApprovalLog == null)
{
entity.CourseApprovalLog = new List <CourseApprovalLog>();
}
entity.CourseApprovalLog.Add(new CourseApprovalLog
{
CreatedByName = entity.CreatedByName,
ActionDate = DateTime.Now,
Remark = "Course " + entity.Title + " goes for Trial.",
ApprovalStatus = ApprovalStatus.None
});
await db.SaveChangesAsync();
ChangeCourseStatusModel data = new ChangeCourseStatusModel
{
CourseId = entity.Id,
CourseName = entity.Title,
CourseEventId = newEvent.Id,
Message = "New course event created"
};
return(Ok(data));
}
else
{
return(BadRequest("Cannot go to Trial if status is not in Draft"));
}
}
catch (Exception e)
{
return(BadRequest(e.Message + " " + e.InnerException.Message));
}
}
public async Task <IHttpActionResult> Publish(int id, int createdBy)
{
var entity = await db.Courses.FindAsync(id);
if (entity == null)
{
return(BadRequest());
}
CourseEvent courseEvent = new CourseEvent();
// check whether a public event has been created
var publicEvent = await db.CourseEvents.FirstOrDefaultAsync(x => x.CourseId == id && x.ViewCategory == ViewCategory.Public);
if (publicEvent == null)
{
var newEvent = new CourseEvent
{
Name = "Public Course",
CourseId = id,
AllowablePercentageBeforeWithdraw = entity.DefaultAllowablePercentageBeforeWithdraw,
CreatedBy = createdBy,
EnrollmentCode = $"PUBLIC ({entity.Id})",
ViewCategory = ViewCategory.Public,
Status = entity.ViewCategory == ViewCategory.Public ? CourseEventStatus.AvailableToPublic : CourseEventStatus.AvailableToPrivate,
Start = DateTime.Now,
IsDisplayed = entity.ViewCategory == ViewCategory.Public ? true : false
};
db.CourseEvents.Add(newEvent);
await db.SaveChangesAsync();
}
//sum total content - added by wawar
var totalContent = db.CourseContents.Where(x => x.CourseId == id);
entity.TotalContents = totalContent.Count();
var totalModule = db.CourseModules.Where(x => x.CourseId == id);
entity.TotalModules = totalContent.Count();
//end sum
entity.Status = CourseStatus.Published;
if (entity.CourseApprovalLog == null)
{
entity.CourseApprovalLog = new List <CourseApprovalLog>();
}
var createdByName = "";
var user = await db.User.FindAsync(createdBy);
if (user != null)
{
createdByName = user.Name;
}
entity.CourseApprovalLog.Add(new CourseApprovalLog
{
CreatedByName = createdByName,
ActionDate = DateTime.Now,
Remark = "Course " + entity.Title + " is published.",
ApprovalStatus = ApprovalStatus.None
});
await db.SaveChangesAsync();
ChangeCourseStatusModel data = new ChangeCourseStatusModel
{
CourseId = entity.Id,
CourseName = entity.Title,
Message = "Published"
};
return(Ok(data));
}
