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));
}
