public IHttpActionResult Create(int id, AssignmentModel assignment)
{
if (!this.ModelState.IsValid)
{
return(BadRequest(this.ModelState));
}
var teamwork = this.data.TeamWorks.Find(id);
if (teamwork == null)
{
return(BadRequest("Teamwork does not exist - invalid id"));
}
var newAssignment = new Assignment
{
Name = assignment.Name,
Description = assignment.Description,
Priority = assignment.Priority
};
teamwork.Assignments.Add(newAssignment);
this.data.SaveChanges();
assignment.Id = newAssignment.Id;
return(Ok(assignment));
}
public IHttpActionResult Put(int id, AssignmentModel assignment)
{
if (!this.ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var existingAssignment = this.GetCurrentAssignment(id);
if (existingAssignment == null)
{
return(BadRequest("Assignment does not exist."));
}
var newAssignment = new Assignment
{
Name = assignment.Name,
Description = assignment.Description,
Priority = assignment.Priority,
Status = (AssignmentStatus)Enum.Parse(typeof(AssignmentStatus), assignment.Status)
};
existingAssignment = newAssignment;
this.data.SaveChanges();
return(Ok());
}
public ActionResult CreateAssignment([Bind(Include = "Name,Description,Deadline,ActivityId,Activity")] AssignmentModel assignmentModel)
{
if (ModelState.IsValid)
{
var activities = db.Activities.Find(assignmentModel.ActivityId).ModulId;
var modul = db.Moduls.Find(activities).CourseId;
var users = db.Users.Where(u => u.Course.Id == modul);
foreach (var user in users)
{
AssignmentModel model = new AssignmentModel
{
ActivityId = assignmentModel.ActivityId,
Activity = assignmentModel.Activity,
Deadline = assignmentModel.Deadline,
Description = assignmentModel.Description,
Name = assignmentModel.Name,
UserId = user.UserName
};
db.Assignments.Add(model);
}
db.SaveChanges();
}
return(RedirectToAction("IndexAssignment", "Activity", new { id = assignmentModel.ActivityId }));
}
public ResponseModel Update(AssignmentModel model)
{
var state = repo.Update(model);
SetObjectResponse(model, state);
return(response);
}
public async System.Threading.Tasks.Task WhenAddRangeDifferentResourcesAsyncToDifferentTasks_ThenPublishedAssignmentsAreReturned()
{
// ARRANGE
var assignmentModel = new AssignmentModel()
{
Id = Guid.NewGuid(),
ResourceId = _enterpriseResource.Id,
TaskId = _publishedTask.Id,
Start = DateTime.Now.Date,
Finish = DateTime.Now.AddDays(1).Date
};
var publishedTask2 = await CreateTestTask();
var assignmentModel2 = new AssignmentModel()
{
Id = Guid.NewGuid(),
ResourceId = _enterpriseResource2.Id, //DIFFERENT RESOURCE
TaskId = publishedTask2.Id, // DIFFERENT TASK
Start = DateTime.Now.AddDays(2).Date,
Finish = DateTime.Now.AddDays(3).Date
};
// ACT
var publishedAssignments = await _client.AddRangeAsync(_publishedProject,
new List <AssignmentModel>() { assignmentModel, assignmentModel2 });
// ASSERT
Assert.NotNull(publishedAssignments);
Assert.Equal(2, publishedAssignments.Count());
}
// GET: Organization/OrganizationHome page, including a search for projects by name
public IActionResult OrganizationHome(string searchString = null)
{
if (searchString != null)
{
searchString = searchString.ToLower(); // so comparisaons aren't case-sensitive
}
//OrganizationModel org = _db.GetOrganization(
// new Guid(User.Claims.ToList()[(int)UserClaimsIndex.OrganizationModel].Value));
//org.Projects = org.Projects
// .Where(p => p.Name.ToLower().Contains(searchString))
// .OrderBy(x => x.Deadline)
// .ToList();
UserModel user = this.GetLoggedInUserByEmail(_db);
OrganizationHomeModel model = new()
{
Organization = new OrganizationModel(),//org,
User = user,
UserAssignment = new AssignmentModel()
{
AssigneeAccess = UserPosition.ADMIN,
OrganizationId = Guid.NewGuid(),
ProjectIdTreePath = new List <Guid>()
{
new Guid()
}
} //this.GetLoggedInUsersAssignment(_db, user)
};
return(View(model));
}
public IActionResult AssignmentInStatus(string token, string status)
{
switch (status)
{
case AssignmentStatus.Pending:
case AssignmentStatus.Accepted:
case AssignmentStatus.Appointed:
case AssignmentStatus.Duplicated:
var apiManager = DomainHub.GetDomain <IApiManager>();
if (apiManager.VerifyToken(token))
{
var applicationManager = DomainHub.GetDomain <IApplicationManager>();
var assignments = applicationManager
.GetAssignments(status, true)
.Select(assignment =>
{
var assignmentModel = new AssignmentModel(assignment);
assignmentModel.Order.AnyCategory = true;
return(assignmentModel);
});
return(Json(assignments));
}
break;
}
return(Accepted());
}
public ActionResult IndexRead(int caseID)
{
var varCase = caseRepository.Find(caseID);
bool hasAccess = workerroleactionpermissionnewRepository.HasPermission(caseID, CurrentLoggedInWorkerRoleIDs, CurrentLoggedInWorker.ID, varCase.ProgramID, varCase.RegionID, varCase.SubProgramID, varCase.JamatkhanaID, Constants.Areas.CaseManagement, Constants.Controllers.CaseWorker, Constants.Actions.Index, true);
if (!hasAccess)
{
WebHelper.CurrentSession.Content.ErrorMessage = "You are not eligible to do this action";
return(RedirectToAction(Constants.Actions.AccessDenied, Constants.Controllers.Home, new { Area = String.Empty }));
}
AssignmentModel assignmentModel = new AssignmentModel();
assignmentModel.CaseWorker = new CaseWorker();
assignmentModel.CaseSupportCircle = new CaseSupportCircle();
assignmentModel.CaseSupportCircle.CaseID = caseID;
assignmentModel.CaseWorker.CaseID = caseID;
assignmentModel.CaseWorker.CaseMemberList = casememberRepository.FindAllByCaseIDForDropDownList(caseID);
//List<SelectListItem> workerList = workerRepository.FindAllPossible(varCase.ProgramID, varCase.RegionID, varCase.SubProgramID);
List <SelectListItem> workerList = workerRepository.NewFindAllPossible(varCase.ProgramID, varCase.RegionID, varCase.SubProgramID);
if (workerList == null || (workerList != null && workerList.Count == 0))
{
assignmentModel.ErrorMessage = "There is no worker found for Program:" + varCase.Program.Name + ", Region:" + varCase.Region.Name + ", Sub-Program:" + varCase.SubProgram.Name;
}
else
{
workerList = workerList.OrderBy(m => m.Text).ToList();
}
ViewBag.PossibleWorkerList = workerList;
ViewBag.DisplayID = caseRepository.Find(caseID).DisplayID;
ViewBag.CaseID = caseID;
return(View(assignmentModel));
}
private void CreateButton_Click(object sender, EventArgs e)
{
if (ValidateForm())
{
// combines date data and time data from two picker controls
DateTime finish = DateFinishPicker.Value.Date +
HoursPicker.Value.TimeOfDay;
//initializes the assignment with 4 parameter constructor
AssignmentModel model = new AssignmentModel(
CommentRichBox.Text,
false,
DateTime.Now,
finish);
//inserts the new assignmnet into the database
OrganizerLibrary.GlobalConfig.Connections[0].CreateAssignment(model);
DisplayData[DisplayData.Count - 1] = model;
DisplayData.Add(new AssignmentModel());
}
else
{
MessageBox.Show("This form has invalid information. Please check it and try again.");
}
}
public void AddAssignment(AssignmentModel assignmentModel)
{
var assign = _iAssignmentMapper.Map(assignmentModel);
_iAssignmentRepository.Add(assign);
_iAssignmentRepository.SaveChanges();
}
public AssignmentModel Map(AssignmentAPIModel assignmentAPIModel)
{
if (assignmentAPIModel == null)
{
return(null);
}
var labModel = _iLaboratoryAPIMapper.Map(assignmentAPIModel.Laboratory);
var assign = new AssignmentModel();
assign.Name = assignmentAPIModel.Name;
assign.Deadline = assignmentAPIModel.Deadline;
assign.Description = assignmentAPIModel.Description;
assign.Laboratory = labModel;
return(assign);
//return new AssignmentModel
//{
// AssignmentStatus = assignment,
// Student = studentModel,
// Laboratory = labModel
//};
//AssignmentModel assignmentModel = new AssignmentModel(assignment, studentModel, labModel);
//return assignmentModel;
}
private async void DeleteAssignmentBtn_Click(object sender, RoutedEventArgs e)
{
IParentWindow parent = ParentFinder.FindParent <AdminPanelWindow>(this);
MessageDialogResult r = await parent.ShowMessage("Warning",
"Are you sure you want to delete this assginment",
MessageDialogStyle.AffirmativeAndNegative);
if (r == MessageDialogResult.Negative)
{
return;
}
// // TODO - Delete the selected Assignment
AssignmentModel model = (AssignmentModel)assignmentsGrid.SelectedItem;
if (GlobalConfig.Connection.DeleteAssignment_ById(model.Id))
{
Assignments.Remove(model);
WireUpLists(Assignments);
// TODO - Delete the selected term
}
else
{
await parent.ShowMessage("Deletion Error",
"The selected assignment can't be deleted beacause it has an exam",
MessageDialogStyle.Affirmative);
// TODO - ADD a MessageBox
}
}
public async System.Threading.Tasks.Task WhenAddAsync_IfIdExists_ThenNullIsReturned()
{
// ARRANGE
var assignmentModel = new AssignmentModel()
{
Id = Guid.NewGuid(),
ResourceId = _enterpriseResource.Id,
TaskId = _publishedTask.Id,
Start = DateTime.Now,
Finish = DateTime.Now.AddDays(1)
};
var assignmentModel2 = new AssignmentModel()
{
Id = assignmentModel.Id,
ResourceId = _enterpriseResource.Id,
TaskId = _publishedTask.Id,
Start = DateTime.Now,
Finish = DateTime.Now.AddDays(1)
};
// ACT
await _client.AddAsync(_publishedProject, assignmentModel);
var publishedAssignemntSecondTime = await _client.AddAsync(_publishedProject, assignmentModel2);
// ASSERT
Assert.Null(publishedAssignemntSecondTime);
}
public IActionResult DeleteFileFinalInformSupervisor([FromBody] FileModel model)
{
ReportModel modelResult = new ReportModel();
try {
AssignmentModel Asign = HttpContext.Session.Get <AssignmentModel>("ReporModelSupervisor");
UserModel UserSession = HttpContext.Session.Get <UserModel>("UserSesion");
modelResult = Asign.Report;
List <FileModel> listFiles = new List <FileModel>();
foreach (var item in modelResult.Files)
{
FileModel newFile = new FileModel();
newFile = item;
newFile.ModifiedBy = UserSession.Name;
//if (item.Status != 0) {
if (item.Id == model.Id)
{
newFile.Status = 1;
}
listFiles.Insert(0, newFile);
//}
}
modelResult.Files = listFiles;
Asign.Report = modelResult;
HttpContext.Session.Remove("ReporModelSupervisor");
HttpContext.Session.Set <AssignmentModel>("ReporModelSupervisor", Asign);
} catch (Exception) {
}
return(PartialView("_FileListSupervisor", modelResult));
}
public static List <TaskModel> FindAssignments(string useremail, string eventid)
{
AssignmentModel data = new AssignmentModel
{
UserEmail = useremail,
EventID = eventid
};
string sql = @"select TaskName, EventID
from dbo.Assignments where (UserEmail = @UserEmail and EventID = @EventID);";
List <AssignmentModel> assignmentsList = SqlDataAccess.FindItems(sql, data);
List <TaskModel> myTasksList = new List <TaskModel>();
foreach (var assignment in assignmentsList)
{
TaskModel data2 = new TaskModel
{
TaskName = assignment.TaskName,
linkEventId = assignment.EventID
};
string sql2 = @"select TaskName, TaskDescription, Deadline
from dbo.Tasks where (TaskName = @TaskName and linkEventID = @linkEventId);";
myTasksList.AddRange(SqlDataAccess.FindItems(sql2, data2));
}
return(myTasksList);
}
public async Task <IActionResult> ReportsOTDetail()
{
AssignmentModel assig = new AssignmentModel();
UserModel UserSession = HttpContext.Session.Get <UserModel>("UserSesion");
try {
string userId = UserSession.Id;
int rolId = ConvertUserType.GetStatusUserInt(UserSession.UserType);
var Id = HttpContext.Session.GetString("IdOTInformes");
assig = await _assignmentService.GetReportByIdAsync(rolId.ToString(), Id, userId);
List <ContactModel> FerreContacts = new List <ContactModel>();
FerreContacts.AddRange(GetChargeInFerreyrosContact("Supervisor", assig.FerreyrosContacts));
FerreContacts.AddRange(GetChargeInFerreyrosContact("Líder", assig.FerreyrosContacts));
FerreContacts.AddRange(GetChargeInFerreyrosContact("Técnico", assig.FerreyrosContacts));
assig.FerreyrosContacts = FerreContacts;
CalculateDelayedHours(ref assig);
if (assig.Report.Files != null)
{
AddStatusFile(ref assig);
}
HttpContext.Session.SetString("TitleForm", "Consulta de Informes");
HttpContext.Session.SetString("ButtonBack", "BackToReports");
} catch (Exception) {
return(RedirectToAction("ConsultationReports", "Reports"));
}
HttpContext.Session.Set <AssignmentModel>("ReporModelSupervisor", assig);
return(View("ReportsOT", assig));
}
public async Task <IActionResult> EditAssignment(string assignmentId)
{
var userId = User.FindFirst(ClaimTypes.NameIdentifier).Value;
Assignment assignment = await _context.GetAssignment(assignmentId);
if (assignment == null || !await _context.ManagesAgency(userId, assignment.AgencyId))
{
return(Forbid());
}
Agency agency = await _context.GetAgency(assignment.AgencyId);
if (agency == null)
{
return(Forbid());
}
AssignmentModel model = new AssignmentModel()
{
AgencyId = assignment.AgencyId,
AssignmentId = assignment.AssignmentId,
Delegated = assignment.IsDelegated,
IsDelegated = assignment.IsDelegated,
Services = await _context.GetServicesForAssignment(assignment.AssignmentId),
Delegations = await _context.GetDelegationsForAssignment(assignment.AssignmentId),
HttpResolvers = await _context.GetHttpResolversForAssignment(assignment.AssignmentId)
};
return(View(model));
}
public void DeleteAssignment(AssignmentModel model)
{
UserModel u = GetUser(model.AssigneeId);
u.Assignments.Remove(model); // todo: return whether or not model was successfully removed?
UpdateUser(u);
}
public async Task <object> Add(AssignmentInputModel assignmentInputModel)
{
var lab = await _context.Lab.FindAsync(assignmentInputModel.LabId);
if (lab == null)
{
return("bad request");
}
var model = new AssignmentModel
{
LabId = assignmentInputModel.LabId,
Name = assignmentInputModel.Name,
Deadline = assignmentInputModel.Deadline,
Description = assignmentInputModel.Description
};
_context.Assignment.Add(model);
try
{
await _context.SaveChangesAsync();
}
catch (Exception)
{
return("bad request");
}
return(model);
}
public void AssignmentComplete(AssignmentModel model)
{
Assignments.Remove(model);
Assignments.Add(model);
WireUpLists(Assignments);
assignmentsGrid.SelectedIndex = assignmentsGrid.Items.Count - 1;
}
public async System.Threading.Tasks.Task WhenAddRangeSameResourceAsyncToSameTask_ThenPublishedAssignmentsAreReturned()
{
// ARRANGE
var assignmentModel = new AssignmentModel()
{
Id = Guid.NewGuid(),
ResourceId = _enterpriseResource.Id,
TaskId = _publishedTask.Id,
Start = DateTime.Now,
Finish = DateTime.Now.AddDays(1)
};
var assignmentModel2 = new AssignmentModel()
{
Id = Guid.NewGuid(),
ResourceId = _enterpriseResource.Id,
TaskId = _publishedTask.Id,
Start = DateTime.Now,
Finish = DateTime.Now.AddDays(1)
};
// ACT
var publishedAssignments = await _client.AddRangeAsync(_publishedProject,
new List <AssignmentModel>() { assignmentModel, assignmentModel2 });
// ASSERT
Assert.NotNull(publishedAssignments);
Assert.Single(publishedAssignments);
}
public async Task <IActionResult> EditAssignment(AssignmentModel model)
{
//RegistryProvider provider = new RegistryProvider();
//string username = User.Identity.Name;
var userId = User.FindFirst(ClaimTypes.NameIdentifier).Value;
if (ModelState.IsValid)
{
Assignment assignment = await _context.Assignments.FindAsync(model.AssignmentId);
if (assignment == null || !await _context.ManagesAgency(userId, assignment.AgencyId))
{
return(Forbid());
}
Agency agency = await _context.GetAgency(assignment.AgencyId);
string assignmentName = model.AssignmentId;
if (assignmentName.Equals(agency.AgencyId, StringComparison.InvariantCultureIgnoreCase))
{
//
}
else if (!assignmentName.StartsWith(agency.AgencyId + ".", StringComparison.InvariantCultureIgnoreCase))
{
assignmentName = agency.AgencyId + "." + assignmentName;
}
assignment.AssignmentId = assignmentName.ToLowerInvariant();
assignment.IsDelegated = model.Delegated;
assignment.LastModified = DateTime.UtcNow;
var updated = await _context.SaveChangesAsync();
return(RedirectToAction("EditAssignment", "Manage", new { assignmentId = assignment.AssignmentId }));
}
return(View(model));
}
public ActionResult ApproveHandler(int id, bool approved) // To approve assignments for teacher
{
AssignmentModel model = db.Assignments.Find(id);
if (approved)
{
model.Redo = false;
model.Approved = true;
db.Assignments.AddOrUpdate(model);
db.SaveChanges();
}
if (!approved)
{
model.Redo = true;
model.Approved = false;
db.Assignments.AddOrUpdate(model);
db.SaveChanges();
}
return(RedirectToAction("IndexAssignment", new { id = model.ActivityId }));
}
public void UpdateAssignment(string workId, string memberId, string status, WorkType type)
{
var assign = assignmentCollection.Find(it => it.Work_id == workId && !it.AbandonDate.HasValue).FirstOrDefault();
AssignmentModel data;
if (assign == null && string.IsNullOrEmpty(memberId))
{
return;
}
if (assign == null && !string.IsNullOrEmpty(memberId))
{
data = new AssignmentModel
{
_id = Guid.NewGuid().ToString(),
Work_id = workId,
Member_id = memberId,
AssignDate = DateTime.Now,
LastestWorkStatus = status,
Type = type
};
assignmentCollection.InsertOne(data);
}
else
{
data = assign;
data.LastestWorkStatus = status;
if (assign.Member_id != memberId)
{
assignmentCollection.FindOneAndUpdate(
Builders <AssignmentModel> .Filter.Eq(it => it._id, data._id),
Builders <AssignmentModel> .Update
.Set(it => it.LastestWorkStatus, data.LastestWorkStatus)
.Set(it => it.AbandonDate, DateTime.Now)
);
data = new AssignmentModel
{
_id = Guid.NewGuid().ToString(),
Work_id = workId,
Member_id = memberId,
AssignDate = DateTime.Now,
LastestWorkStatus = status,
Type = type
};
assignmentCollection.InsertOne(data);
}
else
{
assignmentCollection.FindOneAndUpdate(
Builders <AssignmentModel> .Filter.Eq(it => it._id, data._id),
Builders <AssignmentModel> .Update
.Set(it => it.LastestWorkStatus, data.LastestWorkStatus)
);
}
}
}
public async Task <ActionResult> AssignmentEdit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
AssignmentModel assignmentToUpdate = null;
if (ModelState.IsValid)
{
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(Baseurl);
client.DefaultRequestHeaders.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
string auth = Session["UserEmail"].ToString() + ":" + Session["UserPassword"];
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Authorization", auth);
HttpRequestMessage Req = new HttpRequestMessage(HttpMethod.Get, Baseurl + "api/Assignment/" + id);
var response = await client.GetAsync(Req.RequestUri);
var jsonString = await response.Content.ReadAsStringAsync();
assignmentToUpdate = JsonConvert.DeserializeObject <AssignmentModel>(jsonString);
}
}
if (TryUpdateModel(assignmentToUpdate, "",
new string[] { "LabID", "Title", "Deadline", "Description" }))
{
try
{
if (ModelState.IsValid)
{
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(Baseurl);
client.DefaultRequestHeaders.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
string auth = Session["UserEmail"].ToString() + ":" + Session["UserPassword"];
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Authorization", auth);
HttpRequestMessage Req = new HttpRequestMessage(HttpMethod.Put, Baseurl + "api/Assignment");
Req.Content = new StringContent(Newtonsoft.Json.JsonConvert.SerializeObject(assignmentToUpdate), Encoding.ASCII, "application/json");
var response = await client.PutAsync(Req.RequestUri, Req.Content);
if (response.IsSuccessStatusCode)
{
return(RedirectToAction("AssignmentsIndex"));
}
}
}
}
catch (DataException /* dex */)
{
//Log the error (uncomment dex variable name and add a line here to write a log.
ModelState.AddModelError("", "Unable to save changes. Try again, and if the problem persists, see your system administrator.");
}
}
return(View(assignmentToUpdate));
}
// GET: Activity/Details/5
public ActionResult DetailsAssignment(int?id)
{
AssignmentModel model = db.Assignments.Find(id);
return(PartialView(model));
}
public ActionResult DeleteConfirmed(int id)
{
AssignmentModel assignmentModel = db.Assignments.Find(id);
db.Assignments.Remove(assignmentModel);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public IActionResult Home(AssignmentModel assignment)
{
// TODO: Have user select assignment and direct them to either org home or project home
UserModel u = this.GetLoggedInUserByEmail(_db);
LogInUser(u, assignment);
return(View());
}
private void ConvertToCompleted(AssignmentModel model)
{
if (model.IsCompleted)
{
model.AssignmentGroup.Message = model.CompletedMessage;
model.AssignmentGroup.TestSetting = model.CompletedTestSetting.FromJson <TestSettingModel>();
}
}
private void AddExamBtn_Click(object sender, RoutedEventArgs e)
{
Button btn = (Button)sender;
SelectedAssignment = (AssignmentModel)btn.Tag;
CreateExamWindow win = new CreateExamWindow(this);
win.ShowDialog();
}
public static async Task AddAssignment(this AppDbContext context, AssignmentModel model)
{
var assignment = new Assignment
{
Description = model.description,
CategoryId = model.category.id,
Hours = model.hours
};
context.Assignments.Add(assignment);
await context.SaveChangesAsync();
}
public static async Task UpdateAssignment(this AppDbContext context, AssignmentModel model)
{
var assignment = await context.Assignments.FindAsync(model.id);
assignment.Description = model.description;
assignment.Hours = model.hours;
assignment.CategoryId = model.category.id;
await context.SaveChangesAsync();
}
