public bool Delete(Checklist checklist)
{
bool result = DB.Delete(checklist);
checklist.UserStory.Checklists.Remove(checklist);
return(result);
}
public JsonResult ChecklistCreate(Checklist checklist, bool Check)
{
if (!ModelState.IsValid)
{
Response.StatusCode = 400;
var errorList = ModelState.Values.SelectMany(m => m.Errors)
.Select(e => e.ErrorMessage)
.ToList();
return(Json(errorList, JsonRequestBehavior.AllowGet));
}
checklist.Checked = Check;
db.Checklists.Add(checklist);
db.SaveChanges();
checklist.Task = db.Tasks.Find(checklist.TaskId);
Activity act = new Activity()
{
UserId = checklist.Task.UserId,
Desc = "add checkitem to task " + checklist.Task.Name,
Date = DateTime.Now
};
db.Activities.Add(act);
db.SaveChanges();
return(Json(new
{
checklist.Checked,
checklist.Id,
checklist.Text
}, JsonRequestBehavior.AllowGet));
}
public override void OnControlLoad(object sender, EventArgs e)
{
long transactionMasterId = Conversion.TryCastLong(this.Request["TranId"]);
using (Checklist checklist = new Checklist())
{
checklist.ViewReportButtonText = Titles.ViewThisDelivery;
checklist.EmailReportButtonText = Titles.EmailThisDelivery;
checklist.CustomerReportButtonText = Titles.ViewCustomerCopy;
checklist.Text = Titles.SalesDelivery;
checklist.AttachmentBookName = "transaction";
checklist.OverridePath = "/Modules/Sales/Delivery.mix";
checklist.DisplayWithdrawButton = true;
checklist.DisplayViewReportButton = true;
checklist.DisplayEmailReportButton = true;
checklist.DisplayCustomerReportButton = true;
checklist.DisplayPrintReceiptButton = false;
checklist.DisplayPrintGlEntryButton = true;
checklist.DisplayAttachmentButton = true;
checklist.ReportPath = "~/Modules/Sales/Reports/DeliveryReport.mix";
checklist.CustomerReportPath = "~/Modules/Sales/Reports/DeliveryNoteReport.mix";
checklist.GlAdvicePath = "~/Modules/Finance/Reports/GLAdviceReport.mix";
checklist.ViewPath = "/Modules/Sales/Delivery.mix";
checklist.AddNewPath = "/Modules/Sales/Entry/Delivery.mix";
checklist.UserId = AppUsers.GetCurrent().View.UserId.ToInt();
checklist.AttachmentFileName = HostingEnvironment.MapPath("/Resource/Documents/" + checklist.Text + "-#" + transactionMasterId + ".pdf");
checklist.PartyEmailAddress = Data.Helpers.Parties.GetEmailAddress(AppUsers.GetCurrentUserDB(),
TranBook.Sales, SubTranBook.Delivery, transactionMasterId);
checklist.RestrictedTransactionMode = this.IsRestrictedMode;
this.Placeholder1.Controls.Add(checklist);
}
}
private void btnAddChecklist_Click(object sender, EventArgs e)
{
var name = txtChecklistName.Text.Trim();
if (string.IsNullOrEmpty(name))
{
MessageBox.Show("Name it first.");
return;
}
foreach (ListViewItem item in lsvMain.Items)
{
if (((Checklist)item.Tag).name.ToLower() == name.ToLower())
{
MessageBox.Show("Checklist with that name exists.");
return;
}
}
var checklist = new Checklist(name);
var listItem = new ListViewItem(checklist.name)
{
Text = checklist.name,
Tag = checklist
};
lsvMain.Items.Add(listItem);
}
public async void SetsArchivedToFalse(string uid, string title, int count, bool?archived)
{
var items = new List <CheckItem>();
for (int i = 0; i < count; i++)
{
items.Add(new CheckItem {
Checked = i % 2 == 0, Text = title + i
});
}
var note = new Checklist {
UID = uid, Title = title, Items = items, Archived = archived
};
var expected = new Checklist {
UID = uid, Title = title, Items = items, Archived = false
};
var actual = await repo.Create(note);
expected.Id = actual.Id;
Assert.Equal(expected, actual);
var set = expectedCollection;
set.Add(expected);
AssertCollectionEquals(set);
}
public IActionResult PutChecklist(int id, [FromBody] Checklist entity)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != entity.Id)
{
return(BadRequest());
}
Checklist checklist;
try
{
checklist = _service.Update(id, entity);
}
catch (DbUpdateConcurrencyException)
{
if (!_service.ChecklistExists(id))
{
return(NotFound());
}
else
{
throw new AppException("Update failed");
}
}
return(Ok(checklist));
}
public Checklist addTemplate(Checklist template)
{
template.TimeCreated = DateTime.UtcNow;
_context.Checklist.Add(template);
_context.SaveChanges();
return(_context.Checklist.Where(t => t.TimeCreated.Equals(template.TimeCreated) && t.UserId.Equals(template.UserId)).FirstOrDefault());
}
public void WithId_AChecklist_ReturnsThatChecklist()
{
var expectedChecklist = new Checklist
{
Id = "4f2b8b4d4f2cb9d16d3684c7",
IdBoard = Constants.WelcomeBoardId,
Name = "Checklist",
Pos = 16384,
CheckItems = new List <CheckItem>
{
new CheckItem {
Id = "4f2b8b4d4f2cb9d16d3684c4", Name = "Make your own boards", Pos = 16481
},
new CheckItem {
Id = "4f2b8b4d4f2cb9d16d3684c5", Name = "Invite your team", Pos = 33232
},
new CheckItem {
Id = "4f2b8b4d4f2cb9d16d3684c6", Name = "Enjoy an ice-cold lemonade", Pos = 49687
}
}
}.ToExpectedObject();
var actualChecklist = _trelloReadOnly.Checklists.WithId("4f2b8b4d4f2cb9d16d3684c7");
expectedChecklist.ShouldEqual(actualChecklist);
}
private static string ChecklistKey(Checklist checklist)
{
// int farmInspectionId = checklist.FarmInspectionId; // todo implement this
int farmInspectionId = 0;
return(ChecklistKey(farmInspectionId));
}
public override void OnEnter()
{
if (Settings.IsOfflineMode)
{
MessageBox.Show("Dit scherm is niet beschikbaar in offline mode.");
_router.GoBack();
return;
}
TemplateQuestions.Clear();
if (ViewBag?.Template == null)
{
Checklist = new Checklist();
return;
}
Checklist = ViewBag.Template.GetCleanModel();
const string regex = "\\s{1}[Vv]{1}\\d{1,}$";
if (Regex.Match(Checklist.Name, regex).Success)
{
Checklist.Name = Regex.Replace(Checklist.Name, regex, string.Empty);
}
Checklist.Name += $" v{Checklist.Version}";
RaisePropertyChanged(nameof(Checklist));
_checklistQuestionRepository.GetChecklistQuestions(Checklist.Parent).ForEach(q => TemplateQuestions.Add(q.GetCleanModel()));
_questionRepository.All().ForEach(ExistingQuestions.Add);
}
public async Task <IHttpActionResult> PutChecklist(int id, Checklist checklist)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != checklist.Id)
{
return(BadRequest());
}
db.Entry(checklist).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ChecklistExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public Item insert(int checklistId, Item item)
{
//Find checklist
Checklist checklist = _checklistRepo.GetChecklistById(checklistId)
.Include("Items")
.ToList()
.FirstOrDefault();
item.ChecklistId = checklistId;
foreach (var translation in item.Translations.ToList())
{
_translationRepo.InsertTranslation(translation);
}
_itemRepo.InsertItem(item);
checklist.Items.Add(item);
_checklistRepo.UpdateChecklist(checklistId, checklist);
if (_checklistRepo.Save())
{
return(item);
}
return(null);
}
public async Task <IActionResult> Edit(int id, [Bind("checklistId,Reminder")] Checklist checklist)
{
if (id != checklist.checklistId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(checklist);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ChecklistExists(checklist.checklistId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(checklist));
}
public void Trim()
{
if (!String.IsNullOrEmpty(Title))
{
Title = Title.Trim();
}
if (!String.IsNullOrEmpty(Text))
{
Text = Text.Trim();
}
if (IsChecklist && Checklist != null)
{
for (int i = Checklist.Count - 1; i >= 0; i--)
{
if (!String.IsNullOrEmpty(Checklist[i].Text))
{
Checklist[i].Text = Checklist[i].Text.Trim();
}
if (String.IsNullOrEmpty(Checklist[i].Text))
{
Checklist.RemoveAt(i);
}
}
}
}
public override void OnControlLoad(object sender, EventArgs e)
{
long transactionMasterId = Conversion.TryCastLong(this.Request["TranId"]);
using (Checklist checklist = new Checklist())
{
checklist.Text = Titles.GoodsReceiptNote;
checklist.ViewReportButtonText = Titles.ViewThisNote;
checklist.EmailReportButtonText = Titles.EmailThisNote;
checklist.PartyEmailAddress = Parties.GetEmailAddress(AppUsers.GetCurrentUserDB(), TranBook.Purchase,
SubTranBook.Receipt, transactionMasterId);
checklist.AttachmentBookName = "transaction";
checklist.OverridePath = "/Modules/Purchase/GRN.mix";
checklist.DisplayWithdrawButton = true;
checklist.DisplayViewReportButton = true;
checklist.DisplayEmailReportButton = true;
checklist.DisplayPrintGlEntryButton = true;
checklist.DisplayAttachmentButton = true;
checklist.ReportPath = "~/Modules/Purchase/Reports/GRNReport.mix";
checklist.GlAdvicePath = "~/Modules/Finance/Reports/GLAdviceReport.mix";
checklist.ViewPath = "/Modules/Purchase/GRN.mix";
checklist.AddNewPath = "/Modules/Purchase/Entry/GRN.mix";
checklist.UserId = AppUsers.GetCurrentLogin().View.UserId.ToInt();
checklist.RestrictedTransactionMode = this.IsRestrictedMode;
this.Placeholder1.Controls.Add(checklist);
}
}
public override void OnControlLoad(object sender, EventArgs e)
{
long transactionMasterId = Conversion.TryCastLong(this.Request["TranId"]);
using (Checklist checklist = new Checklist())
{
checklist.ViewReportButtonText = Titles.ViewThisOrder;
checklist.EmailReportButtonText = Titles.EmailThisOrder;
checklist.Text = Titles.SalesOrder;
checklist.AttachmentFileName = HostingEnvironment.MapPath("/Resource/Documents/" + checklist.Text + "-#" + transactionMasterId + ".pdf");
checklist.PartyEmailAddress = Data.Helpers.Parties.GetEmailAddress(AppUsers.GetCurrentUserDB(),
TranBook.Sales, SubTranBook.Order, transactionMasterId);
checklist.AttachmentBookName = "non-gl-transaction";
checklist.OverridePath = "/Modules/Sales/Order.mix";
checklist.DisplayViewReportButton = true;
checklist.DisplayEmailReportButton = true;
checklist.DisplayAttachmentButton = true;
checklist.IsNonGlTransaction = true;
checklist.ReportPath = "~/Modules/Sales/Reports/SalesOrderReport.mix";
checklist.ViewPath = "/Modules/Sales/Order.mix";
checklist.AddNewPath = "/Modules/Sales/Entry/Order.mix";
checklist.UserId = AppUsers.GetCurrent().View.UserId.ToInt();
checklist.RestrictedTransactionMode = this.IsRestrictedMode;
this.Placeholder1.Controls.Add(checklist);
}
}
public void Given_question_requires_booleanresponse_When_no_corresponding_answer_return_false()
{
// Given
var questions = new List<Question>()
{
new Question()
{
Id = 1,
QuestionType = QuestionType.YesNo
}
};
var checklist = new Checklist()
{
Sections = new List<Section>()
{
new Section()
{
Questions = questions
}
}
};
var employeeChecklist = new EmployeeChecklist()
{
Checklist = checklist,
Answers = new List<PersonalAnswer>()
};
// When
var result = employeeChecklist.AreAllQuestionsAnswered();
// Then
Assert.IsFalse(result);
}
public void CRDUserChecklistItemTest()
{
//CreateChecklistItem
List <Priority> priorities = DB.GetPriorities();
List <State> states = DB.GetStates();
List <Classes.Type> types = DB.GetTypes();
List <Project> projects = DB.GetProjects();
if (states.Count == 0)
{
DB.CreateState("AStateName");
states = DB.GetStates();
}
if (projects.Count == 0)
{
DB.CreateProject("aProjectName", "A Description for my project", DateTime.Now);
projects = DB.GetProjects();
}
UserStory userStory = DB.CreateUserStory("aDescription", null, 2, priorities[0], types[0], states[0], projects[0]);
Checklist checklist = DB.CreateCheckList("a bioutifoul name", userStory);
ChecklistItem checklistItem = DB.CreateCheckListItem("a better name", checklist);
//CreateUser
User user = DB.CreateUser("a user name");
Assert.IsTrue(DB.AddUserToChecklistItem(user, checklistItem));
Assert.IsNotNull(DB.GetUserChecklistItem());
Assert.IsTrue(DB.RemoveUserFromChecklistItem(user, checklistItem));
DB.Delete(user);
DB.Delete(userStory);
DB.Delete(checklistItem);
DB.Delete(checklist);
}
public static FireRiskAssessment Create(string title, string reference, long companyId, Checklist checklist, UserForAuditing currentUser)
{
var now = DateTime.Now;
var fireRiskAssessment = new FireRiskAssessment
{
CompanyId = companyId,
Reference = reference,
Title = title,
CreatedBy = currentUser,
CreatedOn = now,
Status = RiskAssessmentStatus.Draft
};
var fireRiskAssessmentChecklist = new FireRiskAssessmentChecklist
{
Checklist = checklist,
FireRiskAssessment = fireRiskAssessment,
CreatedBy = currentUser,
CreatedOn = now
};
fireRiskAssessment.FireRiskAssessmentChecklists.Add(fireRiskAssessmentChecklist);
return fireRiskAssessment;
}
public void CRUDChecklist()
{
//Test Create
ctrl.CreateProject("aProjectName", "A Description for my project", DateTime.Now);
Project project = ctrl.Projects.Last();
ctrl.CreateUserStory("aDescription", null, 2, ctrl.Priorities[0], ctrl.Types[0], project);
UserStory userStory = project.AllUserStories[0];
string aName = "a first name";
Checklist checklist = ctrl.CreateCheckList(aName, userStory);
Assert.AreEqual(aName, checklist.Name);
Assert.AreEqual(userStory.Id, checklist.UserStoryId);
//Test Update
string afterName = "checklist second name";
Assert.IsTrue(ctrl.UpdateCheckList(afterName, new List <ChecklistItem>(), checklist));
Assert.AreEqual(afterName, checklist.Name);
//Test Remove
Assert.IsTrue(ctrl.Delete(checklist));
ctrl.Delete(userStory);
ctrl.Delete(project);
}
/**
* Gets all inspectionitems from DB if they already exists, and creates them if they don't already
*/
private static Inspection GetOrCreateInspectionItems(
ApplicationDbContext ctx,
Checklist checklist,
Inspection inspection)
{
foreach (var ci in checklist.ChecklistChecklistItems.Select(joinItem => joinItem.ChecklistItem))
{
var inspectionItem = inspection.InspectionItems.SingleOrDefault(item => item.ChecklistItem.Id == ci.Id);
if (inspectionItem == null)
{
inspectionItem = new InspectionItem
{
ChecklistItem = ci,
Inspection = inspection
};
inspection.InspectionItems.Add(inspectionItem);
ctx.InspectionItems.Add(inspectionItem);
}
}
TrySave(ctx);
return inspection;
}
public void CRDUserIUsersAssignedTest()
{
ctrl.CreateProject("aProjectName", "A Description for my project", DateTime.Now);
Project project = ctrl.Projects.Last();
ctrl.CreateUser("a user name", project);
User user = ctrl.Users.Last();
Assert.IsTrue(ctrl.AddUserToIUsersAssigned(user, project));
Assert.IsTrue(project.GetUsers().Contains(user));
Assert.IsTrue(ctrl.RemoveUserFromIUsersAssigned(user, project));
ctrl.CreateUserStory("aDescription", null, 2, ctrl.Priorities[0], ctrl.Types[0], project);
UserStory userStory = project.AllUserStories[0];
Assert.IsTrue(ctrl.AddUserToIUsersAssigned(user, userStory));
Assert.IsTrue(userStory.GetUsers().Contains(user));
Assert.IsTrue(ctrl.RemoveUserFromIUsersAssigned(user, userStory));
Checklist checklist = ctrl.CreateCheckList("a bioutifoul name", userStory);
ctrl.CreateCheckListItem("a better name", checklist);
ChecklistItem checklistItem = checklist.ChecklistItems[0];
Assert.IsTrue(ctrl.AddUserToIUsersAssigned(user, checklistItem));
Assert.IsTrue(checklistItem.GetUsers().Contains(user));
Assert.IsTrue(ctrl.RemoveUserFromIUsersAssigned(user, checklistItem));
ctrl.Delete(user);
ctrl.Delete(checklistItem);
ctrl.Delete(checklist);
ctrl.Delete(userStory);
ctrl.Delete(project);
}
public JsonResult CheckEdit(int id, string text, bool check)
{
Checklist checklist = db.Checklists.Find(id);
if (!ModelState.IsValid)
{
Response.StatusCode = 400;
var errorList = ModelState.Values.SelectMany(m => m.Errors)
.Select(e => e.ErrorMessage)
.ToList();
return(Json(errorList, JsonRequestBehavior.AllowGet));
}
checklist.Checked = check;
checklist.Text = text;
checklist.Task = db.Tasks.Find(checklist.TaskId);
db.Entry(checklist).State = EntityState.Modified;
db.SaveChanges();
return(Json(new
{
checklist.Checked,
checklist.Id,
checklist.Text
}, JsonRequestBehavior.AllowGet));
}
public IHttpActionResult PostChecklist(Checklist checklist)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
using (DbContextTransaction transaction = db.Database.BeginTransaction())
{
try
{
db.CheckLists.Add(checklist);
if (checklist.CheckListImage != null)
{
foreach (ChecklistImage item in checklist.CheckListImage)
{
db.CheckListImages.Add(item);
}
}
db.SaveChanges();
transaction.Commit();
}
catch (Exception ex)
{
transaction.Rollback();
throw;
}
}
return(CreatedAtRoute("DefaultApi", new { id = checklist.Id }, checklist));
}
public void DeserializesChecklists()
{
var id = "someid";
var uid = "someuid";
var archived = true;
var title = "sometitle";
var items = new List <CheckItem> {
new CheckItem {
Text = "grapes"
}, new CheckItem {
Checked = true, Text = "apples"
}
};
var expected = new Checklist
{
Id = id,
UID = uid,
Archived = archived,
Title = title,
Items = items
};
var json = $"{{ 'Id': '{id}', 'Type': 'Checklist', 'UID': '{uid}', 'Archived': {archived.ToString().ToLower()}, 'Title': '{title}', 'Items': [{{'Checked': false, 'Text': 'grapes'}}, {{'Checked': true, 'Text': 'apples'}}] }}";
var note = JsonConvert.DeserializeObject <Note>(json, converter);
var checklist = Assert.IsAssignableFrom <Checklist>(note);
Assert.Equal(expected, checklist);
}
public HttpResponseMessage PutChecklistAPI(Checklist checklist)
{
if (checklist == null)
{
return(new HttpResponseMessage(HttpStatusCode.NotFound));
}
_context.Entry(checklist).State = EntityState.Modified;
try
{
_context.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!ChecklistExists(checklist.Id))
{
return(new HttpResponseMessage(HttpStatusCode.NotFound));
}
else
{
throw;
}
}
return(new HttpResponseMessage(HttpStatusCode.OK));
}
private void SetCheckListImages_Upload(Checklist checklist, string ImageURL)
{
List <ChecklistImage> lstImages = new List <ChecklistImage>();
//Local Images
for (int i = 0; i < Request.Files.Count; i++)
{
Guid guid = Guid.NewGuid();
string filename = Request.Files[i].FileName;
if (filename == "")
{
break;
}
string type = filename.Substring(filename.IndexOf("."), filename.Length - filename.IndexOf("."));
string mapPath = "~/Content/UserFiles/Images/" + guid.ToString() + type;
string physicalPath = Server.MapPath(mapPath);
ChecklistImage checklistImage = new ChecklistImage();
checklistImage.Path = mapPath;
checklistImage.Type = 1;
checklistImage.CheckListId = checklist.Id;
lstImages.Add(checklistImage);
Request.Files[i].SaveAs(physicalPath);
}
//URL Images
if (ImageURL != null)
{
SaveImageURL(lstImages, ImageURL, checklist.Id);
}
checklist.CheckListImage = lstImages;
}
public Checklist UpdateChecklist(int id, Checklist checklist)
{
Checklist newChecklist;
try
{
newChecklist = _ctx.Checklists.Where(c => c.Id == id).FirstOrDefault();
if (newChecklist != null)
{
newChecklist.Name = checklist.Name;
newChecklist.isActive = checklist.isActive;
newChecklist.UpdatedOn = DateTime.UtcNow;
return(newChecklist);
}
//TODO Log error
return(null);
}
catch (Exception ex)
{
throw ex;
}
}
// Start is called before the first frame update
void Start()
{
// gets the checklist if it hasn't been set.
if (tutorialList == null)
{
tutorialList = GetComponent <Checklist>();
}
// goes through the steps list and adds them to the Checklist
for (int i = 0; i < stepList.Count; i++)
{
tutorialList.AddStep(stepList[i]);
}
// active tutorial checklist
tutorialList.SetActiveList(true);
// if the tutorial list is active, show the text
// if(tutorialList != null && tutorialList.activeList)
// {
// if (!tutorialList.IsCompleteList())
// stepText.text = "Step " + tutorialList.GetCurrentStepNumber() + " - " +
// tutorialList.GetCurrentStep().name + ": " + tutorialList.GetCurrentStep().description;
// else
// stepText.text = "Tutorial is Complete!";
//
// currStep++;
// }
// steps.Add(new Step());
}
public Checklist delete(int id)
{
bool isCheckListDeleted = true;
bool isItemsDeleted = true;
bool isTranslationsDeleted = true;
Checklist checklistToDelete = _checklistRepo.GetChecklistById(id)
.Include("Items")
.Single();
var itemsToDelete = checklistToDelete.Items.ToList();
Checklist deletedChecklist = _checklistRepo.DeleteChecklist(id);
if (!itemsToDelete.Any() || itemsToDelete == null)
{
isCheckListDeleted = _checklistRepo.Save();
if (!isCheckListDeleted)
{
deletedChecklist = null;
}
return(deletedChecklist);
}
else
{
//Delete all Items and corresponding translations
foreach (var item in itemsToDelete)
{
Item itemToDelete = _itemRepo.GetItemById(item.Id).FirstOrDefault();
List <Translation> translationsToDelete = _translationRepo.GetTranslations(item.Id).ToList();
foreach (var translationToDelete in translationsToDelete)
{
if (translationToDelete != null)
{
_translationRepo.DeleteTranslation(translationToDelete);
}
}
if (itemToDelete != null)
{
_itemRepo.DeleteItem(itemToDelete);
}
}
isCheckListDeleted = _checklistRepo.Save();
isTranslationsDeleted = _translationRepo.Save();
isItemsDeleted = _itemRepo.Save();
if (!isTranslationsDeleted || !isTranslationsDeleted && !isTranslationsDeleted)
{
deletedChecklist = null;
}
return(deletedChecklist);
}
}
public ActionResult _Dislike(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Checklist product = db.Checklists.Find(id);
if (product == null)
{
return(HttpNotFound());
}
product.Dislikes++;
if (ModelState.IsValid)
{
db.Entry(product).State = EntityState.Modified;
db.SaveChanges();
}
product = db.Checklists.Find(id);
ViewBag.test = 1;
return(PartialView("_TableRow", product));
}
public async Task <IActionResult> PutChecklist(int id, Checklist checklist)
{
if (id != checklist.Id)
{
return(BadRequest());
}
_context.Entry(checklist).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ChecklistExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public void SetUp()
{
_clientId = 3423L;
_currentUser = new UserForAuditing { Id = Guid.NewGuid() };
_checklist = new Checklist {Id = 42L};
_fireRiskAssessment = FireRiskAssessment.Create(
"Fire Risk Assessment 2", "GRA02", _clientId, _checklist, _currentUser);
}
public ChecklistDto MapWithSections(Checklist entity)
{
if (entity == null)
{
return null;
}
var dto = Map(entity);
dto.Sections = new SectionDtoMapper().Map(entity.Sections);
return dto;
}
public void Start()
{
notebook1.CurrentPage = 0;
checklist = new Checklist (this, tree);
back.Sensitive = false;
OnNotesFocusOutEvent(null, null);
Pango.FontDescription big = new Pango.FontDescription ();
big.Size = (int)(26 * Pango.Scale.PangoScale);
currentItem.ModifyFont (big);
LoadItems ();
}
public void Given_checklist_status_is_completed_and_consultant_blacklisted_and_no_QaAdvisor_to_assign_to_then_AutoAssignChecklist_set_status_to_completed()
{
//GIVEN
_getCompletedChecklistQuery.Setup(x => x.Count(_consultant.FullName)).Returns(() => 0);
_consultant.AddToBlacklist();
var checklist = new Checklist() { Status= Checklist.STATUS_COMPLETED, QaAdvisor = null, ChecklistCreatedBy = "Tywin Lannister"};
var target = GetTarget();
//WHEN
target.AutoAssignChecklist(checklist);
//THEN
Assert.That(checklist.Status, Is.EqualTo(Checklist.STATUS_COMPLETED));
Assert.That(checklist.QaAdvisor, Is.Null);
}
public void Given_checklist_status_is_completed_and_consultant_blacklisted_then_DoesChecklistNeedToBeChecked_returns_true()
{
//GIVEN
_getCompletedChecklistQuery.Setup(x => x.Count(_consultant.FullName))
.Returns(() => 0);
_consultant.AddToBlacklist();
var checklist = new Checklist() { Status= Checklist.STATUS_COMPLETED, QaAdvisor = null, ChecklistCreatedBy = "Tywin Lannister"};
var target = GetTarget();
//WHEN
var result = target.DoesChecklistNeedToBeChecked(checklist);
//THEN
Assert.That(result, Is.True);
}
public ChecklistDto Map(Checklist entity)
{
if (entity == null)
{
return null;
}
var dto = new ChecklistDto
{
Id = entity.Id,
Title = entity.Title,
Description = entity.Description,
ChecklistRiskAssessmentType = entity.ChecklistRiskAssessmentType
};
return dto;
}
public void When_Create_called_Then_it_is_created_as_expected()
{
var user = new UserForAuditing {Id = Guid.NewGuid()};
var checklist = new Checklist {Id = 123L};
var fireRiskAssessment = FireRiskAssessment.Create("Test title", "TestRef", 234L, checklist, user);
Assert.That(fireRiskAssessment.CompanyId, Is.EqualTo(234L));
Assert.That(fireRiskAssessment.Reference, Is.EqualTo("TestRef"));
Assert.That(fireRiskAssessment.Title, Is.EqualTo("Test title"));
Assert.That(fireRiskAssessment.CreatedBy, Is.EqualTo(user));
Assert.That(fireRiskAssessment.CreatedOn, Is.Not.Null);
Assert.That(fireRiskAssessment.CreatedOn, Is.Not.EqualTo(default(DateTime)));
Assert.That(fireRiskAssessment.Status, Is.EqualTo(RiskAssessmentStatus.Draft));
Assert.That(fireRiskAssessment.FireRiskAssessmentChecklists, Is.Not.Null);
Assert.That(fireRiskAssessment.FireRiskAssessmentChecklists.Count, Is.EqualTo(1));
Assert.That(fireRiskAssessment.FireRiskAssessmentChecklists[0].Checklist, Is.EqualTo(checklist));
Assert.That(fireRiskAssessment.LatestFireRiskAssessmentChecklist.Checklist, Is.EqualTo(checklist));
}
public void SetUp()
{
_emailSender = new Mock<IEmailSender>();
_checklistRepository = new Mock<ICheckListRepository>();
_qaRepository = new Mock<IQaAdvisorRepository>();
_urlConfiguration = new Mock<ISafeCheckEmailLinkBaseUrlConfiguration>();
_urlConfiguration.Setup(x => x.GetBaseUrl()).Returns(string.Empty);
var checklistId = Guid.NewGuid();
var assignedToId = Guid.NewGuid();
_checklist = new Checklist() {ClientId = 1111, Id = checklistId, ChecklistCompletedBy = "Gareth Wilby"};
_checklistRepository.Setup(x => x.GetById(It.IsAny<Guid>())).Returns(_checklist);
var qaAdvisor = new QaAdvisor() {Id = Guid.NewGuid()};
_qaRepository.Setup(x => x.GetById(It.IsAny<Guid>())).Returns(qaAdvisor);
}
public void Given_a_query_and_dates_are_BST_then_dates_return_as_UTC()
{
//given
var BSTDate = new DateTime(2014, 04, 06);
var clientId = 234234;
var clientAccountNumber = "TESTACTULAR";
var expectedStatus = "Open";
var checklist = new Checklist(){VisitDate = BSTDate};
var site = new SiteAddressResponse() {Id = 1212431241, SiteName = "Rekall", Postcode = "MARS 7TU"};
_clientDetailsService
.Setup(x => x.GetSite(clientId, (int)site.Id))
.Returns(() => site);
_clientDetailsService
.Setup(x => x.GetByClientAccountNumber(clientAccountNumber))
.Returns(() => new CompanyDetailsResponse() { CAN = clientAccountNumber, Id = clientId });
_clientDetailsService
.Setup(x => x.Get(It.IsAny<int>()))
.Returns(new CompanyDetails() { CAN = "Can" });
_getChecklistsQuery.Setup(x => x.WithClientId(It.IsAny<int>())).Returns(_getChecklistsQuery.Object);
_getChecklistsQuery.Setup(x => x.WithConsultantName(It.IsAny<string>())).Returns(_getChecklistsQuery.Object);
_getChecklistsQuery.Setup(x => x.WithStatus(It.IsAny<string>())).Returns(_getChecklistsQuery.Object);
_getChecklistsQuery.Setup(x => x.WithStatusDateBetween(It.IsAny<DateTime?>(), It.IsAny<DateTime?>())).Returns(_getChecklistsQuery.Object);
_getChecklistsQuery.Setup(x => x.Execute())
.Returns(() => new List<ChecklistIndex>()
{
new ChecklistIndex() {ClientId = clientId, SiteId = (int?) site.Id, Status = expectedStatus, VisitDate = BSTDate, CompletedDate = BSTDate, SubmittedDate = BSTDate, QaAdvisorAssignedOn = BSTDate}
});
//when
var target = new ChecklistController(_dependencyFactory.Object);
var result = target.Query(clientAccountNumber, null, null, null, false, false, null, null);
Assert.That(result.First().VisitDate, Is.EqualTo(BSTDate.ToUniversalTime()));
Assert.That(result.First().CompletedOn, Is.EqualTo(BSTDate.ToUniversalTime()));
Assert.That(result.First().SubmittedOn, Is.EqualTo(BSTDate.ToUniversalTime()));
Assert.That(result.First().QaAdvisorAssignedOn, Is.EqualTo(BSTDate.ToUniversalTime()));
}
public void WithId_AChecklist_ReturnsThatChecklist()
{
var expectedChecklist = new Checklist
{
Id = "4f2b8b4d4f2cb9d16d3684c7",
IdBoard = Constants.WelcomeBoardId,
Name = "Checklist",
CheckItems = new List<CheckItem>
{
new CheckItem { Id = "4f2b8b4d4f2cb9d16d3684c4", Name = "Make your own boards" },
new CheckItem { Id = "4f2b8b4d4f2cb9d16d3684c5", Name = "Invite your team" },
new CheckItem { Id = "4f2b8b4d4f2cb9d16d3684c6", Name = "Enjoy an ice-cold lemonade" }
}
}.ToExpectedObject();
var actualChecklist = _trelloReadOnly.Checklists.WithId("4f2b8b4d4f2cb9d16d3684c7");
expectedChecklist.ShouldEqual(actualChecklist);
}
public void Given_checklist_status_is_completed_and_consultant_blacklisted_and_QaAdvisor_is_assign_to_then_assign_correct_advisor_set_status_to_completed()
{
//GIVEN
var qaAdvisorAssigned = Guid.NewGuid();
_getCompletedChecklistQuery.Setup(x => x.Count(_consultant.FullName)).Returns(() => 0);
_consultant.AddToBlacklist();
_consultant.QaAdvisorAssigned = _qaAdvisor.Id;
var checklist = new Checklist() { Status = Checklist.STATUS_COMPLETED, QaAdvisor = null, ChecklistCreatedBy = "Tywin Lannister",
ChecklistSubmittedBy = "Tywin Lannister"};
var target = GetTarget();
//WHEN
target.AutoAssignChecklist(checklist);
//THEN
//Assert.That(checklist.Status, Is.EqualTo(Checklist.STATUS_COMPLETED));
Assert.That(checklist.QaAdvisor.Id, Is.EqualTo(_qaAdvisor.Id));
}
public void Given_deleted_irns_When_handle_then_deleted_irns_should_not_be_added_to_email()
{
// Given
var handler = GetTarget();
var message = new SendIRNNotificationEmail();
var checklist = new Checklist()
{
Id = Guid.NewGuid(),
EmailAddress = "*****@*****.**"
};
checklist.AddImmediateRiskNotification(new ImmediateRiskNotification()
{
Id = Guid.NewGuid(),
RecommendedImmediateAction = "Test IRN action",
Deleted = false
});
checklist.AddImmediateRiskNotification(new ImmediateRiskNotification()
{
Id = Guid.NewGuid(),
Deleted = true
});
checklist.AddImmediateRiskNotification(new ImmediateRiskNotification()
{
Id = Guid.NewGuid(),
Deleted = true
});
_checklistRepository.Setup(c => c.GetById(It.IsAny<Guid>()))
.Returns(() => checklist);
SendIRNNotificationEmailViewModel viewModelUsedToCreateEmail = null;
handler.Protected()
.Setup("CreateRazorEmailResult", ItExpr.IsAny<SendIRNNotificationEmailViewModel>())
.Callback<SendIRNNotificationEmailViewModel>(viewModel => viewModelUsedToCreateEmail = viewModel);
// When
handler.Object.Handle(message);
// Then
Assert.That(viewModelUsedToCreateEmail.IRNList.Count, Is.EqualTo(1));
}
public void given_checklist_when_CopyToSiteWithoutResponses_then_checklist_copied_to_sites()
{
//GIVEN
var checklist = new Checklist() {Id = Guid.NewGuid(), SiteId = 13123};
_checklistRepo
.Setup(x => x.GetById(checklist.Id))
.Returns(() => checklist);
var siteIds = new int[] { 12,13,14 };
var target = new ChecklistController(_dependencyFactory.Object);
//when
var result = target.CopyToSiteWithoutResponses(checklist.Id, siteIds);
//then
_checklistService.Verify(x => x.CopyToSiteWithoutResponses(checklist.Id, siteIds[0], "test name"));
_checklistService.Verify(x => x.CopyToSiteWithoutResponses(checklist.Id, siteIds[1], "test name"));
_checklistService.Verify(x => x.CopyToSiteWithoutResponses(checklist.Id, siteIds[2], "test name"));
Assert.That(result.Count, Is.EqualTo(3));
}
public void Given_a_draft_checklist_when_assigning_then_status_is_Assigned()
{
//GIVN
var checklist = new Checklist() {Status = "Draft"};
var qaAdvisor = new QaAdvisor();
_checklistRepository
.Setup(x => x.GetById(It.IsAny<Guid>()))
.Returns(() => checklist);
_qaAdvisorRepository
.Setup(x => x.GetById(It.IsAny<Guid>()))
.Returns(() => qaAdvisor);
var target = GetTarget();
var viewModel = new QaAdvisorViewModel();
viewModel.Id = Guid.NewGuid();
//WHEN
target.AssignChecklistToQaAdvisor(Guid.NewGuid(), viewModel);
Assert.That(checklist.Status,Is.EqualTo("Assigned"));
}
public void Given_a_checklist_when_assigning_then_updated_required_is_added()
{
//GIVN
var checklist = new Checklist() {Id = Guid.NewGuid()};
var qaAdvisor = new QaAdvisor();
_checklistRepository
.Setup(x => x.GetById(It.IsAny<Guid>()))
.Returns(() => checklist);
_qaAdvisorRepository
.Setup(x => x.GetById(It.IsAny<Guid>()))
.Returns(() => qaAdvisor);
var target = GetTarget();
var viewModel = new QaAdvisorViewModel();
viewModel.Id = Guid.NewGuid();
//WHEN
target.SendUpdateRequiredEmailNotification(checklist.Id);
Assert.That(checklist.UpdatesRequiredLog.Count, Is.EqualTo(1));
}
public void When_handle_then_Should_Call_Correct_Methods()
{
// Given
var handler = GetTarget();
var message = new SendIRNNotificationEmail();
_checklistRepository.Setup(c => c.GetById(It.IsAny<Guid>()))
.Returns(() =>
{
var checklist = new Checklist()
{
Id = Guid.NewGuid(),
EmailAddress = "*****@*****.**",
};
checklist.AddImmediateRiskNotification(new ImmediateRiskNotification()
{
Id = Guid.NewGuid(),
RecommendedImmediateAction =
"Test IRN action",
Deleted = false
});
return checklist;
}
);
// When
handler.Object.Handle(message);
// Then
_emailSender.Verify(x => x.Send(It.IsAny<RazorEmailResult>()));
handler.Protected().Verify("CreateRazorEmailResult", Times.Once(),
ItExpr.IsAny<SendIRNNotificationEmailViewModel>());
}
public void Given_i_query_by_client_account_number_then_the_site_details_are_set()
{
//given
var clientId = 234234;
var clientAccountNumber = "TESTACTULAR";
var expectedPostcode = "MARS 7TU";
var expectedSiteName = "Rekall";
var expectedAddress = "29 Acaciar Road";
var expectedStatus = "Open";
var checklist = new Checklist();
var site = new SiteAddressResponse() {Id = 1212431241, SiteName = expectedSiteName, Postcode = expectedPostcode, Address1 = expectedAddress};
_clientDetailsService
.Setup(x => x.GetSite(clientId, (int) site.Id))
.Returns(() => site);
_clientDetailsService
.Setup(x => x.GetByClientAccountNumber(clientAccountNumber))
.Returns(() => new CompanyDetailsResponse() {CAN = clientAccountNumber, Id = clientId});
_clientDetailsService
.Setup(x => x.Get(It.IsAny<int>()))
.Returns(new CompanyDetails() { CAN = "Can" });
_checklistRepository.Setup(x => x.Search(clientId, null, null, null, false, null))
.Returns(() => new List<Checklist>()
{
new Checklist() {ClientId = clientId, SiteId = (int?) site.Id, Status = expectedStatus}
});
_checklistRepository.Setup(x => x.GetById(It.IsAny<Guid>()))
.Returns(checklist);
_getChecklistsQuery.Setup(x => x.WithClientId(It.IsAny<int>())).Returns(_getChecklistsQuery.Object);
_getChecklistsQuery.Setup(x => x.WithConsultantName(It.IsAny<string>())).Returns(_getChecklistsQuery.Object);
_getChecklistsQuery.Setup(x => x.WithStatus(It.IsAny<string>())).Returns(_getChecklistsQuery.Object);
_getChecklistsQuery.Setup(x => x.WithStatusDateBetween(It.IsAny<DateTime?>(), It.IsAny<DateTime?>())).Returns(_getChecklistsQuery.Object);
_getChecklistsQuery.Setup(x=> x.Execute())
.Returns(() => new List<ChecklistIndex>()
{
new ChecklistIndex() {ClientId = clientId, SiteId = (int?) site.Id, Status = expectedStatus}
});
//when
var target = new ChecklistController(_dependencyFactory.Object);
var result = target.Query(clientAccountNumber, null, null, null, false, false, null,null);
Assert.That(result.First().Site.Postcode, Is.EqualTo(expectedPostcode));
Assert.That(result.First().Site.SiteName, Is.EqualTo(expectedSiteName));
Assert.That(result.First().Site.Address1, Is.EqualTo(expectedAddress));
Assert.That(result.First().Status, Is.EqualTo(expectedStatus));
}
public void Given_a_checklist_is_assigned_and_a_consultant_completes_checklist_then_status_stays_assigned()
{
var Id = Guid.NewGuid();
// Given
var checklist = new Checklist();
checklist.Status = "Assigned";
var parameters = new CreateUpdateChecklistParameters()
{
Id = Id,
ClientId = 11,
SiteId = 22,
CoveringLetterContent = "Letter content",
Status = "Completed",
VisitBy = "VisitBy",
VisitDate = "10/10/2013",
VisitType = "Visit Type",
MainPersonSeenName = "Person Seen Name",
AreasVisited = "Areas Visited",
AreasNotVisited = "Areas Not Visited",
EmailAddress = "email",
ImpressionType = new ImpressionType() { Comments = "comments" },
ImmediateRiskNotifications = new List<AddImmediateRiskNotificationParameters>(),
SubmittedBy = "username",
SubmittedOn = DateTime.Now,
Submit = true
};
checklist.UpdateChecklistDetails(parameters);
Assert.That(checklist.Status,Is.EqualTo("Assigned"));
}
public void Given_checklist_status_is_NOT_completed_then_DoesChecklistNeedToBeChecked_returns_false()
{
//GIVEN
var checklist = new Checklist() { Status = Checklist.STATUS_DRAFT, QaAdvisor = null };
var target = GetTarget();
//WHEN
var result = target.DoesChecklistNeedToBeChecked(checklist);
//THEN
Assert.That(result, Is.False);
}
public void given_parameters_when_query_then_execute_is_called_with_correct_parameters()
{
//given
int clientId = 1234;
string can = "CAN01";
string checklistCreatedBy ="consultant.name";
string visitDate = DateTime.Now.ToShortDateString();
string checklistStatus = "Draft";
bool includeDeleted = false;
bool excludeSubmitted = true;
var checklist = new Checklist();
var site = new SiteAddressResponse() {Id = 1234L,};
_clientDetailsService
.Setup(x => x.GetByClientAccountNumber(can))
.Returns(() => new CompanyDetailsResponse() {CAN = can, Id = clientId});
_clientDetailsService
.Setup(x => x.Get(It.IsAny<int>()))
.Returns(new CompanyDetails() {CAN = "Can"});
_clientDetailsService
.Setup(x => x.GetSite(It.IsAny<int>(), It.IsAny<int>()))
.Returns(() => site);
_getChecklistsQuery.Setup(x => x.WithClientId(It.IsAny<int>())).Returns(_getChecklistsQuery.Object);
_getChecklistsQuery.Setup(x => x.WithStatus(It.IsAny<string>())).Returns(_getChecklistsQuery.Object);
_getChecklistsQuery.Setup(x => x.WithStatusDateBetween(It.IsAny<DateTime?>(), It.IsAny<DateTime?>())).Returns(_getChecklistsQuery.Object);
_getChecklistsQuery.Setup(x => x.WithConsultantName(It.IsAny<string>())).Returns(_getChecklistsQuery.Object);
_getChecklistsQuery
.Setup(
x =>
x.Execute())
.Returns(() => new List<ChecklistIndex>()
{
new ChecklistIndex() {ClientId = clientId, SiteId = (int?) site.Id, Status = checklistStatus}
});
_checklistRepository.Setup(x => x.GetById(It.IsAny<Guid>()))
.Returns(checklist);
//when
var target = new ChecklistController(_dependencyFactory.Object);
target.Query(can, checklistCreatedBy, visitDate, checklistStatus, includeDeleted, excludeSubmitted, null, null);
//then
_getChecklistsQuery
.Verify(
x =>
x.Execute());
}
public void Given_an_answer_exists_when_DoesAnAnswerObjectExistForQuestion_then_return_true()
{
var questions = new List<Question>()
{
new Question()
{
Id = 1,
QuestionType = QuestionType.YesNo
}
};
var checklist = new Checklist()
{
Sections = new List<Section>()
{
new Section()
{
Questions = questions
}
}
};
var employeeChecklist = new EmployeeChecklist()
{
Checklist = checklist,
Answers = new List<PersonalAnswer>()
{
new PersonalAnswer() {
BooleanResponse = true,
Question = new Question()
{
Id = 1,
QuestionType = QuestionType.YesNo
}}
}
};
var result = employeeChecklist.DoesAnAnswerObjectExistForQuestion(employeeChecklist.Answers[0].Question);
Assert.IsTrue(result);
}
public void Given_a_checklist_is_assigned_when_Delete_then_deleted_by_recorded()
{
var username = "******";
// Given
var checklist = new Checklist();
checklist.Status = "Assigned";
checklist.MarkForDelete(null, username);
Assert.That(checklist.Deleted, Is.True);
Assert.That(checklist.DeletedBy, Is.EqualTo(username));
Assert.That(checklist.DeletedBy, Is.Not.Null);
}
public void Given_checklist_status_is_submitted_when_calling_AssignChecklistToQaAdvisor_then_assign_will_fail()
{
//GIVEN
var qaAdvisorAssigned = Guid.NewGuid();
var checklist = new Checklist()
{
Status = Checklist.STATUS_SUBMITTED
};
var target = GetTarget();
//WHEN
target.AssignChecklistToQaAdvisor(checklist, _qaAdvisor);
//THEN
Assert.That(checklist.Status, Is.EqualTo(Checklist.STATUS_SUBMITTED));
}
public void Given_an_answer_does_not_exist_when_DoesAnAnswerObjectExistForQuestion_then_return_false()
{
var questions = new List<Question>()
{
new Question()
{
Id = 1,
QuestionType = QuestionType.YesNo
}
};
var checklist = new Checklist()
{
Sections = new List<Section>()
{
new Section()
{
Questions = questions
}
}
};
var employeeChecklist = new EmployeeChecklist()
{
Checklist = checklist,
Answers = new List<PersonalAnswer>()
};
var result = employeeChecklist.DoesAnAnswerObjectExistForQuestion(questions[0]);
Assert.IsFalse(result);
}
public void Given_an_question_is_unanswered_when_IsQuestionAnswered_then_returns_false()
{
var questions = new List<Question>()
{
new Question()
{
Id = 1,
QuestionType = QuestionType.YesNo
}
};
var checklist = new Checklist()
{
Sections = new List<Section>()
{
new Section()
{
Questions = questions
}
}
};
var employeeChecklist = new EmployeeChecklist()
{
Checklist = checklist,
Answers = new List<PersonalAnswer>()
{
new PersonalAnswer() {
BooleanResponse = null,
Question = new Question()
{
Id = 1,
QuestionType = QuestionType.YesNo
}}
}
};
var result = employeeChecklist.IsQuestionAnswered(employeeChecklist.Answers[0].Question);
Assert.IsFalse(result);
}
public void Given_a_question_is_text_only_When_IsQuestionAnswered_returns_true()
{
var questions = new List<Question>()
{
new Question()
{
Id = 1,
QuestionType = QuestionType.AdditionalInfo
}
};
var checklist = new Checklist()
{
Sections = new List<Section>()
{
new Section()
{
Questions = questions
}
}
};
var employeeChecklist = new EmployeeChecklist()
{
Checklist = checklist,
Answers = new List<PersonalAnswer>()
{
new PersonalAnswer() {
BooleanResponse = null,
AdditionalInfo = "the answer",
Question = new Question()
{
Id = 1,
QuestionType = QuestionType.AdditionalInfo
}}
}
};
var result = employeeChecklist.IsQuestionAnswered(employeeChecklist.Answers[0].Question);
Assert.IsTrue(result);
}
public void ToString_EqualsName()
{
var checklist = new Checklist { Name = "a name" };
Assert.That(checklist.ToString(), Is.EqualTo("a name"));
}
