public void AddFileEvidence_addsEvidence() { DocumentUpload document = createSampleDocumentUpload(); Dispute dispute = createSampleDispute(); DisputeEvidence evidence = gateway.Dispute.AddFileEvidence(dispute.Id, document.Id).Target; Assert.NotNull(evidence); DisputeEvidence foundEvidence = gateway.Dispute.Find(dispute.Id).Target.Evidence[0]; Assert.Null(evidence.Category); Assert.NotNull(foundEvidence); }
public async Task AddTextEvidenceAsync_failsToAddEvidenceWithUnSupportedCategory() { Dispute dispute = await createSampleDisputeAsync(); TextEvidenceRequest request = new TextEvidenceRequest { Category = "NOTAREALCATEGORY", Content = "evidence", }; var result = await gateway.Dispute.AddTextEvidenceAsync(dispute.Id, request); Assert.IsFalse(result.IsSuccess()); Assert.AreEqual(ValidationErrorCode.DISPUTE_CAN_ONLY_CREATE_EVIDENCE_WITH_VALID_CATEGORY, result.Errors.ForObject("Dispute").OnField("Evidence")[0].Code); }
public ActionResult Create([Bind(Include = "DisputeStatus,Comments,CorrectAmount,DeleteTransaction")] Dispute dispute,Int32 id) { if (ModelState.IsValid) { dispute.Transaction = db.Transactions.Single(t => t.TransactionID == id); dispute.DisputeStatus = 0; db.Disputes.Add(dispute); db.SaveChanges(); Success(string.Format("Dispute successfully created."), true); return RedirectToAction("Index", "ManageAccounts"); } ViewBag.AllTransactions = new SelectList(db.Transactions.ToList(), "TransactionID", "TransactionDescription"); return View(dispute); }
// GET: Disputes/Edit/5 public ActionResult Edit(string id) { if (id == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } Dispute dispute = db.Disputes.Find(id); if (dispute == null) { return(HttpNotFound()); } ViewBag.TransactionID = new SelectList(db.Transactions, "TransactionID", "Description", dispute.TransactionID); return(View(dispute)); }
public ActionResult Edit(int id, [Bind("Id,OrderId,OpenedDate,ArbiterId,Result,Status")] Dispute dispute) { if (ModelState.IsValid) { Dispute newDispute = disputeRepository.Find(id); newDispute.Result = dispute.Result; newDispute.Status = dispute.Status; disputeRepository.Update(id, newDispute); return(RedirectToAction(nameof(Index))); } return(View(dispute)); }
public void AddFileEvidence_failsToAddEvidenceWithUnSupportedCategory() { DocumentUpload document = createSampleDocumentUpload(); Dispute dispute = createSampleDispute(); FileEvidenceRequest request = new FileEvidenceRequest { Category = "NOTAREALCATEGORY", DocumentId = document.Id, }; var result = gateway.Dispute.AddFileEvidence(dispute.Id, request); Assert.IsFalse(result.IsSuccess()); Assert.AreEqual(ValidationErrorCode.DISPUTE_CAN_ONLY_CREATE_EVIDENCE_WITH_VALID_CATEGORY, result.Errors.ForObject("Dispute").OnField("Evidence")[0].Code); }
public void Accept_changesDisputeStatusToAccepted() { Dispute dispute = createSampleDispute(); var result = gateway.Dispute.Accept(dispute.Id); Assert.IsTrue(result.IsSuccess()); Dispute finalizedDispute = gateway.Dispute.Find(dispute.Id).Target; Assert.AreEqual(DisputeStatus.ACCEPTED, finalizedDispute.Status); Dispute disputeFromTransaction = gateway.Transaction.Find(dispute.Transaction.Id).Disputes[0]; Assert.AreEqual(DisputeStatus.ACCEPTED, disputeFromTransaction.Status); }
public async Task AddFileEvidenceAsync_whenDisputeNotOpenErrors() { DocumentUpload document = await createSampleDocumentUploadAsync(); Dispute dispute = await createSampleDisputeAsync(); await gateway.Dispute.AcceptAsync(dispute.Id); var result = await gateway.Dispute.AddFileEvidenceAsync(dispute.Id, document.Id); Assert.IsFalse(result.IsSuccess()); Assert.AreEqual(ValidationErrorCode.DISPUTE_CAN_ONLY_ADD_EVIDENCE_TO_OPEN_DISPUTE, result.Errors.ForObject("Dispute").OnField("Status")[0].Code); Assert.AreEqual("Evidence can only be attached to disputes that are in an Open state", result.Errors.ForObject("Dispute").OnField("Status")[0].Message); }
public void TestClassDispute_MethodAddUserReplacementvalue_ValueDoesNotExistAddNewReplacementValue() { //Arrange Dispute myDispute = new Dispute("Season", "Advent", "522bb79455449d881b004d27"); List <ReplacementValue> expectedValue = new List <ReplacementValue>() { new ReplacementValue("Advent", "522bb79455449d881b004d27"), new ReplacementValue("Lent", "522bb79455449d881b004d27") }; //Act myDispute.AddUserReplacementvalue("Lent", "522bb79455449d881b004d27"); //Assert CollectionAssert.AreEqual(expectedValue.AsReadOnly(), myDispute.getReplacementValues()); }
public async Task AddFileEvidenceAsync_addsEvidence() { Dispute dispute = await createSampleDisputeAsync(); DocumentUpload document = await createSampleDocumentUploadAsync(); Result <DisputeEvidence> evidenceResult = await gateway.Dispute.AddFileEvidenceAsync(dispute.Id, document.Id); Assert.NotNull(evidenceResult.Target); Result <Dispute> foundResult = await gateway.Dispute.FindAsync(dispute.Id); DisputeEvidence foundEvidence = foundResult.Target.Evidence[0]; Assert.NotNull(foundEvidence); }
public async Task AddTextEvidenceAsync_showsNewRecordInFind() { Dispute dispute = await createSampleDisputeAsync(); Result <DisputeEvidence> evidenceResult = await gateway.Dispute.AddTextEvidenceAsync(dispute.Id, "my text evidence"); DisputeEvidence evidence = evidenceResult.Target; Assert.NotNull(evidence); Result <Dispute> foundEvidenceResult = await gateway.Dispute.FindAsync(dispute.Id); DisputeEvidence foundEvidence = foundEvidenceResult.Target.Evidence[0]; Assert.AreEqual(evidence.Id, foundEvidence.Id); }
public ActionResult Create([Bind(Include = "DisputeID,DisputeAmount,CustomerDescription")] Dispute dispute, int Id) { Transaction transaction = db.Transactions.Find(Id); dispute.Status = Status.WaitingOnManager; dispute.Transaction = transaction; if (ModelState.IsValid) { db.Disputes.Add(dispute); db.SaveChanges(); transaction.Dispute = dispute; return(RedirectToAction("Index")); } return(View(dispute)); }
public void RemoveEvidence_removesEvidenceFromTheDispute() { Dispute dispute = createSampleDispute(); DisputeEvidence evidence = gateway.Dispute.AddTextEvidence(dispute.Id, "my text evidence").Target; Assert.NotNull(evidence); var result = gateway.Dispute.RemoveEvidence(dispute.Id, evidence.Id); Assert.IsTrue(result.IsSuccess()); Dispute editedDispute = gateway.Dispute.Find(dispute.Id).Target; Assert.AreEqual(0, editedDispute.Evidence.Count); }
public void Constructor_populatesTransaction() { XmlDocument doc = new XmlDocument(); doc.LoadXml(Payload_attributes()); XmlNode newNode = doc.DocumentElement; var node = new NodeWrapper(newNode); var result = new Dispute(node); Assert.AreEqual("new_transaction_id", result.Transaction.Id); Assert.AreEqual(101m, result.Transaction.Amount); Assert.IsNull(result.Transaction.OrderId); Assert.AreEqual("Visa", result.Transaction.PaymentInstrumentSubtype); Assert.IsNull(result.Transaction.PurchaseOrderNumber); Assert.AreEqual(DateTime.Parse("2017-06-21T20:44:41Z"), result.Transaction.CreatedAt); }
public void Constructor_handlesEmptyFields() { XmlDocument doc = new XmlDocument(); doc.LoadXml(Payload_attributesWithEmptyValues()); XmlNode newNode = doc.DocumentElement; var node = new NodeWrapper(newNode); var result = new Dispute(node); Assert.IsNull(result.Amount); Assert.IsNull(result.DateOpened); Assert.IsNull(result.DateWon); Assert.IsEmpty(result.Evidence); Assert.IsNull(result.ReplyByDate); Assert.IsEmpty(result.StatusHistory); }
public void FindAsync_returnsDisputeWithGivenId() { Task.Run(async () => #endif { Result<Dispute> disputeResult = await gateway.Dispute.FindAsync("open_dispute"); Dispute dispute = disputeResult.Target; Assert.AreEqual(31m, dispute.AmountDisputed); Assert.AreEqual(0m, dispute.AmountWon); Assert.AreEqual("open_dispute", dispute.Id); Assert.AreEqual(DisputeStatus.OPEN, dispute.Status); Assert.AreEqual("open_disputed_transaction", dispute.Transaction.Id); } #if net452 ).GetAwaiter().GetResult(); }
public void RemoveEvidence_errorsWhenDisputeNotOpen() { Dispute dispute = createSampleDispute(); DisputeEvidence evidence = gateway.Dispute.AddTextEvidence(dispute.Id, "my text evidence").Target; Assert.NotNull(evidence); gateway.Dispute.Accept(dispute.Id); var result = gateway.Dispute.RemoveEvidence(dispute.Id, evidence.Id); Assert.IsFalse(result.IsSuccess()); Assert.AreEqual(ValidationErrorCode.DISPUTE_CAN_ONLY_REMOVE_EVIDENCE_FROM_OPEN_DISPUTE, result.Errors.ForObject("Dispute").OnField("Status")[0].Code); Assert.AreEqual("Evidence can only be removed from disputes that are in an Open state", result.Errors.ForObject("Dispute").OnField("Status")[0].Message); }
public void FinalizeAsync_changesDisputeStatusToDisputed() { Task.Run(async () => #endif { Dispute dispute = await createSampleDisputeAsync(); var result = gateway.Dispute.Finalize(dispute.Id); Assert.IsTrue(result.IsSuccess()); Result<Dispute> finalizedDisputeResult = await gateway.Dispute.FindAsync(dispute.Id); Dispute finalizedDispute = finalizedDisputeResult.Target; Assert.AreEqual(DisputeStatus.DISPUTED, finalizedDispute.Status); } #if net452 ).GetAwaiter().GetResult(); }
public void TestClassDispute_MethodAddUserReplacementvalue_ValueAlreadyExistsJustAddTheUser() { //Arrange Dispute myDispute = new Dispute("Season", "Advent", "522bb79455449d881b004d27"); List <ReplacementValue> expectedValue = new List <ReplacementValue>() { new ReplacementValue("Advent", "522bb79455449d881b004d27") }; expectedValue[0].AddInsitutionId("9999979455449d881b004d27"); //Act myDispute.AddUserReplacementvalue("Advent", "9999979455449d881b004d27"); //Assert CollectionAssert.AreEqual(expectedValue.AsReadOnly(), myDispute.getReplacementValues()); }
public async Task RemoveEvidenceAsync_removesEvidenceFromTheDispute() { Dispute dispute = await createSampleDisputeAsync(); Result <DisputeEvidence> evidenceResult = await gateway.Dispute.AddTextEvidenceAsync(dispute.Id, "my text evidence"); DisputeEvidence evidence = evidenceResult.Target; Assert.NotNull(evidence); var result = await gateway.Dispute.RemoveEvidenceAsync(dispute.Id, evidence.Id); Assert.IsTrue(result.IsSuccess()); Dispute editedDispute = gateway.Dispute.Find(dispute.Id).Target; Assert.AreEqual(0, editedDispute.Evidence.Count); }
internal override void Export(string table) { base.Export(table); table = GetType().Name; var vals = new List <object> { Id, EntityId_1.DBExport(), EntityId_2.DBExport(), SiteId_1.DBExport(), SiteId_2.DBExport(), Dispute.DBExport() }; Database.ExportWorldItem(table, vals); }
public void TestClassDispute_MethodUpdateUserReplacementValue_UserReplacementValueDoesNotAlreadyExist() { //Arrange Dispute myDispute; List <ReplacementValue> expectedValue = new List <ReplacementValue>() { new ReplacementValue("advent", "522bb79455449d881b004d27"), new ReplacementValue("lent", "522bb79455449d881b004d27") }; expectedValue[0].RemoveInstituionId("522bb79455449d881b004d27"); //Act myDispute = new Dispute("Season", "Advent", "522bb79455449d881b004d27"); myDispute.UpdateUserReplacementValue("Lent", "Advent", "522bb79455449d881b004d27"); //Assert are equal CollectionAssert.AreEqual(expectedValue.AsReadOnly(), myDispute.getReplacementValues()); }
public void AddTextEvidenceAsync_whenDisputeNotOpenErrors() { Task.Run(async () => #endif { Dispute dispute = await createSampleDisputeAsync(); await gateway.Dispute.AcceptAsync(dispute.Id); var result = await gateway.Dispute.AddTextEvidenceAsync(dispute.Id, "my text evidence"); Assert.IsFalse(result.IsSuccess()); Assert.AreEqual(ValidationErrorCode.DISPUTE_CAN_ONLY_ADD_EVIDENCE_TO_OPEN_DISPUTE, result.Errors.ForObject("Dispute").OnField("Status")[0].Code); Assert.AreEqual("Evidence can only be attached to disputes that are in an Open state", result.Errors.ForObject("Dispute").OnField("Status")[0].Message); } #if net452 ).GetAwaiter().GetResult(); }
public void AddTextEvidenceAsync_addsTextEvidence() { Task.Run(async () => #endif { Dispute dispute = await createSampleDisputeAsync(); Result<DisputeEvidence> evidenceResult = await gateway.Dispute.AddTextEvidenceAsync(dispute.Id, "my text evidence"); DisputeEvidence evidence = evidenceResult.Target; Assert.NotNull(evidence.Id); Assert.NotNull(evidence.CreatedAt); Assert.AreEqual("my text evidence", evidence.Comment); Assert.Null(evidence.SentToProcessorAt); Assert.Null(evidence.Url); } #if net452 ).GetAwaiter().GetResult(); }
public void AddFileEvidenceAsync_addsEvidence() { Task.Run(async () => #endif { Dispute dispute = await createSampleDisputeAsync(); DocumentUpload document = await createSampleDocumentUploadAsync(); Result<DisputeEvidence> evidenceResult = await gateway.Dispute.AddFileEvidenceAsync(dispute.Id, document.Id); Assert.NotNull(evidenceResult.Target); Result<Dispute> foundResult = await gateway.Dispute.FindAsync(dispute.Id); DisputeEvidence foundEvidence = foundResult.Target.Evidence[0]; Assert.NotNull(foundEvidence); } #if net452 ).GetAwaiter().GetResult(); }
public ActionResult Adjust([Bind(Include = "DisputeID,Status,DisputeComment,CorrectAmount,DeleteTransaction")] Dispute dispute, int?id) { if (id == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } Transaction trans = db.Transactions.Find(db.Disputes.Find(id).Transactions.TransactionID); if (ModelState.IsValid) { db.Entry(dispute).State = EntityState.Modified; dispute.Status = DisputeStatus.Adjusted; dispute.Transactions = trans; db.SaveChanges(); //Todo: Send back to the respective details page of the transaction for which a claim has been made return(RedirectToAction("Details", "Transaction", new { id = dispute.Transactions.TransactionID })); } return(View(dispute)); }
public ActionResult Resolve(int?id) { if (id == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } Dispute dispute = db.Disputes.Find(id); if (dispute == null) { return(HttpNotFound()); } ViewBag.SenderID = dispute.Transaction.AccountSenderID; ViewBag.Sender = dispute.Transaction.AccountSender; ViewBag.OldAmount = dispute.Transaction.TransactionAmount; ViewBag.DisputeID = new SelectList(db.Transactions, "TransactionID", "TransactionDescription", dispute.DisputeID); ViewBag.Email = dispute.Transaction.AppUser.Email; return(View(dispute)); }
public void AddTextEvidenceAsync_showsNewRecordInFind() { Task.Run(async () => #endif { Dispute dispute = await createSampleDisputeAsync(); Result<DisputeEvidence> evidenceResult = await gateway.Dispute.AddTextEvidenceAsync(dispute.Id, "my text evidence"); DisputeEvidence evidence = evidenceResult.Target; Assert.NotNull(evidence); Result<Dispute> foundEvidenceResult = await gateway.Dispute.FindAsync(dispute.Id); DisputeEvidence foundEvidence = foundEvidenceResult.Target.Evidence[0]; Assert.AreEqual(evidence.Id, foundEvidence.Id); } #if net452 ).GetAwaiter().GetResult(); }
public void AddTextEvidence_addsEvidenceWithCateogry() { Dispute dispute = createSampleDispute(); var textEvidenceRequest = new TextEvidenceRequest { Content = "my content", Category = "DEVICE_ID", }; DisputeEvidence evidence = gateway.Dispute.AddTextEvidence(dispute.Id, textEvidenceRequest).Target; Assert.NotNull(evidence); DisputeEvidence foundEvidence = gateway.Dispute.Find(dispute.Id).Target.Evidence[0]; Assert.NotNull(evidence.Category); Assert.AreEqual(evidence.Category, "DEVICE_ID"); Assert.NotNull(foundEvidence); }
public ActionResult Create([Bind(Include = "DisputeID,DisputeComments,CorrectAmount,DeleteTransaction")] Dispute dispute) { if (ModelState.IsValid) { Transaction TransactionToLink = db.Transactions.Find(dispute.DisputeID); TransactionToLink.isBeingDisputed = true; dispute.Transaction = TransactionToLink; dispute.CurrentStatus = "Submitted"; db.Disputes.Add(dispute); db.SaveChanges(); return(RedirectToAction("CreateDisputeConfirmation", "Disputes")); } Transaction transaction = db.Transactions.Find(dispute.DisputeID); List <Transaction> TransactionToDisplay = new List <Transaction>(); TransactionToDisplay.Add(transaction); ViewBag.DisputeID = new SelectList(TransactionToDisplay, "TransactionID", "Description"); return(View(dispute)); }