/// <summary>
/// Sets the statues of contracts to replaced where they match the given list of statuses.
/// </summary>
/// <param name="previousContracts">List of contracts to update.</param>
/// <param name="replaceableStatuses">list of statuses to filter by.</param>
/// <returns>Async Task.</returns>
private async Task ReplaceContractsWithGivenStatuses(IEnumerable <Repository.DataModels.Contract> previousContracts, int[] replaceableStatuses)
{
if (previousContracts.Any(p => replaceableStatuses.Contains(p.Status)))
{
int ukprn = previousContracts.First().Ukprn;
// Contracts found
var listToUpdate = previousContracts.Where(p => replaceableStatuses.Contains(p.Status)).ToList();
_logger.LogInformation($"[{nameof(ReplaceContractsWithGivenStatuses)}] found [{listToUpdate.Count}] contracts that need the status set to replaced.");
foreach (var item in listToUpdate)
{
_logger.LogInformation($"[{nameof(ReplaceContractsWithGivenStatuses)}] Replacing contract [{item.ContractNumber}-{item.ContractVersion}] with Id [{item.Id}]");
ContractStatus requiredContractStatus = (ContractStatus)item.Status;
ContractStatus newContractStatus = ContractStatus.Replaced;
var response = await _repository.UpdateContractStatusAsync(item.Id, requiredContractStatus, newContractStatus);
string msg = $"Contract [{response.ContractNumber}-{response.ContractVersion}] with Id [{response.Id}] has been replaced. " +
$"The contract status before was {response.Status.ToString("G")}. " +
$"The contract status after is {response.NewStatus.ToString("G")}.";
await _auditService.TrySendAuditAsync(new AuditModels.Audit()
{
Action = ActionType.ContractReplaced,
Severity = SeverityLevel.Information,
Ukprn = ukprn,
Message = msg,
User = _appName
});
}
}
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Status,Enable")] ContractStatus contractStatus)
{
if (id != contractStatus.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(contractStatus);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ContractStatusExists(contractStatus.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(contractStatus));
}
public void UpdateContractConfirmApprovalAsync_ReturnsContractNotFoundExceptionResult_Test()
{
//Arrange
ContractStatus requiredContractStatus = ContractStatus.ApprovedWaitingConfirmation;
ContractStatus newContractStatus = ContractStatus.Approved;
int searchContractId = 1;
Contract dummyContract = null;
var mockUnitOfWork = Mock.Of <IUnitOfWork>(MockBehavior.Strict);
Mock.Get(mockUnitOfWork)
.Setup(u => u.CommitAsync())
.Returns(Task.CompletedTask)
.Verifiable();
var mockRepo = Mock.Of <IRepository <Contract> >(MockBehavior.Strict);
Mock.Get(mockRepo)
.Setup(r => r.GetByIdAsync(searchContractId))
.ReturnsAsync(dummyContract);
SetMockErrorLogger();
//Act
var contractRepo = new ContractRepository(mockRepo, mockUnitOfWork, _mockLogger.Object);
Func <Task> act = async() => await contractRepo.UpdateContractStatusAsync(searchContractId, requiredContractStatus, newContractStatus);
//Assert
act.Should().Throw <ContractNotFoundException>();
Mock.Get(mockRepo).Verify(r => r.GetByIdAsync(searchContractId), Times.Once);
Mock.Get(mockUnitOfWork).Verify(u => u.CommitAsync(), Times.Never);
_mockLogger.VerifyAll();
}
/// <inheritdoc/>
public async Task <UpdatedContractStatusResponse> WithdrawalAsync(UpdateContractWithdrawalRequest request)
{
_logger.LogInformation($"[{nameof(WithdrawalAsync)}] called with contract number: {request.ContractNumber} and contract version {request.ContractVersion}.");
var contract = await _repository.GetByContractNumberAndVersionWithIncludesAsync(request.ContractNumber, request.ContractVersion, ContractDataEntityInclude.Datas);
ContractStatus newContractStatus = request.WithdrawalType;
_contractValidator.Validate(contract, request);
_contractValidator.ValidateStatusChange(contract, newContractStatus);
var updatedContractStatusResponse = new UpdatedContractStatusResponse
{
Id = contract.Id,
ContractNumber = contract.ContractNumber,
ContractVersion = contract.ContractVersion,
Ukprn = contract.Ukprn,
Status = (ContractStatus)contract.Status,
Action = ActionType.ContractWithdrawal
};
contract.Status = (int)newContractStatus;
await _contractDocumentService.UpsertOriginalContractXmlAsync(contract, request);
await _repository.UpdateContractAsync(contract);
updatedContractStatusResponse.NewStatus = (ContractStatus)contract.Status;
await _mediator.Publish(updatedContractStatusResponse);
return(updatedContractStatusResponse);
}
private DataModels.Contract GetContract(ContractStatus newStatus = ContractStatus.PublishedToProvider)
{
return(new DataModels.Contract()
{
Id = 1, ContractNumber = "abc", ContractVersion = 1, Status = (int)newStatus
});
}
internal static void RemoveMemory(ContractStatus objectValue)
{
if (DicContractStatus.ContainsKey(objectValue.Id))
{
DicContractStatus.Remove(objectValue.Id);
}
}
public IHttpActionResult PutContractStatus(int id, ContractStatus contractStatus)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != contractStatus.Id)
{
return(BadRequest());
}
db.Entry(contractStatus).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!ContractStatusExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
private ContractTrackingReference CreateContractTrackingReference(long contractId, Guid itemReference,
ContractTrackingState state = ContractTrackingState.ActionsPending,
ContractStatus contractStatus = ContractStatus.AvailableForApproval)
{
var contract = FluentContract
.Create()
.ApplyDefaults()
.ContractStatus(contractStatus)
.Save(this);
var trackingReference = new ContractTrackingReference()
{
ContractId = contract.Id, ItemReference = itemReference.ToString(), State = state
};
var roleIds = Enumerable.Empty <long>();
var changeSet = base.contractTrackingReferenceRecordType.GetNewChangeSet() as ChangeSet <long, ContractTrackingReference>;
var changeSetSettings = new ProcessChangeSetSettings(username: MrAdmin.Name);
var itemRef = 1L;
changeSet.AddCreate(itemRef, trackingReference, roleIds, roleIds);
var processResult = contractTrackingReferenceRecordType.ProcessChangeSet(PreliminaryContractDataService, changeSet, changeSetSettings);
return(processResult.SuccessfullyCreatedItems[processResult.SuccessfullyCreated[itemRef]] as ContractTrackingReference);
}
public SerializableContractListItem ToXMLItem()
{
return(new SerializableContractListItem()
{
AcceptorID = AcceptorID,
AssigneeID = AssigneeID,
// Yes, it converts to and from, but all in the name of serialization
Availability = Availability.ToString(),
Buyout = Buyout,
Collateral = Collateral,
ContractID = ContractID,
DateAccepted = DateAccepted,
DateCompleted = DateCompleted,
DateExpired = DateExpired,
DateIssued = DateIssued,
EndStationID = EndStationID,
ForCorp = ForCorp,
IssuerCorpID = IssuerCorpID,
IssuerID = IssuerID,
NumDays = NumDays,
Price = Price,
Reward = Reward,
Status = ContractStatus.ToString(),
StartStationID = StartStationID,
Title = Title,
Type = XMLType,
Volume = Volume
});
}
/// <summary>
/// Initializes a new instance of the <see cref="ContractUpdateConcurrencyException"/> class.
/// </summary>
/// <param name="contractNumber">Contract number.</param>
/// <param name="contractVersion">Contract version number.</param>
/// <param name="status">Contract status.</param>
public ContractUpdateConcurrencyException(string contractNumber, int contractVersion, ContractStatus status)
: base($"Contract may have been modified or deleted since Contract were loaded - Contract Number: {contractNumber}, ContractVersion: {contractVersion}.")
{
ContractNumber = contractNumber;
ContractVersion = contractVersion;
Status = status;
}
public Restaurant(string name, int openingHour, int closingHour,
SubscriptionType subscriptionType, ContractStatus contractStatus, PhoneNumberValue phoneNumber,
string imageUrl, Locality locality, GeographicLocation location, string description,
string descriptionEng)
{
CheckRule(new OpeningAndClosingHoursAreValid(openingHour, closingHour));
CheckRule(new ConditionMustBeTrueRule(subscriptionType != SubscriptionType.Invalid,
"subscription must be valid"));
CheckRule(new ConditionMustBeTrueRule(contractStatus != ContractStatus.Invalid,
"contract must be valid"));
CheckRule(new ConditionMustBeTrueRule(phoneNumber != null,
"phone number be valid"));
ImageUrl = imageUrl;
Locality = locality;
GeographicLocation = location;
Description = description;
DescriptionEng = descriptionEng;
Name = name;
OpeningHour = openingHour;
ClosingHour = closingHour;
SubscriptionType = subscriptionType;
ContractStatus = contractStatus;
State = RestaurantState.Open;
ExpirationDate = subscriptionType.GetExpirationTime();
PhoneNumber = phoneNumber;
}
public async Task <bool> Delete(ContractStatus ContractStatus)
{
if (await ValidateId(ContractStatus))
{
}
return(ContractStatus.IsValidated);
}
internal string UpdateSaleContractStatusCore(ExtendedIdentityDbContext dbContext,
SaleContract contract, ContractStatus contractStatus, string userName)
{
if (contract == null)
{
return("SaleContract model为空。");
}
try
{
contract.ContractStatus = contractStatus;
string errorMessage2 = AddOrUpdateSaleContractFinancialObjsSecond(
dbContext, userName, contract);
if (!string.IsNullOrWhiteSpace(errorMessage2))
{
return(errorMessage2);
}
int effectedRows = dbContext.SaveChanges();
if (effectedRows < 1)
{
return("修改SaleContract审核状态失败。");
}
}
catch (Exception ee)
{
LogHelper.Error("修改SaleContract审核状态失败。", ee);
return(ee.Message);
}
return(string.Empty);
}
public Tuple <Transaction.Transaction, Contract> Deploy(DeployParams param, int attempts, int interval)
{
if (string.IsNullOrEmpty(code) || init == null || init.Count() <= 0)
{
throw new Exception("Cannot deploy without code or initialisation parameters.");
}
Transaction.Transaction transaction = new Transaction.Transaction();
transaction.ID = param.ID;
transaction.Version = param.Version;
transaction.Nonce = param.Nonce;
transaction.GasPrice = param.GasPrice;
transaction.GasLimit = param.GasLimit;
transaction.SenderPubKey = param.SenderPubKey;
transaction.ToAddr = NIL_ADDRESS;
transaction.Amount = "0";
transaction.Code = this.code.Replace("/\\", "");
transaction.Data = JsonConvert.SerializeObject(this.init);
transaction.Provider = this.provider;
transaction = this.prepareTx(transaction, attempts, interval);
if (transaction.IsRejected())
{
this.contractStatus = ContractStatus.Rejected;
return(Tuple.Create <Transaction.Transaction, Contract>(transaction, this));
}
this.contractStatus = ContractStatus.Deployed;
this.address = ContractFactory.GetAddressForContract(transaction);
return(Tuple.Create <Transaction.Transaction, Contract>(transaction, this));
}
public bool Delete(ContractStatus contractStatus)
{
using (var ContractStatusRepository = _factory.GetRepository <ContractStatus>())
{
return(ContractStatusRepository.Delete(contractStatus));
}
}
public static int UpdateContract(string contractId, int customerId, string accountName,
ContractStatus status, decimal balance, string firstName, string lastName, string email,
string companyName, string propertyNames, string propertyValues)
{
return(EcommerceProvider.UpdateContract(contractId, customerId, accountName, (int)status, balance,
firstName, lastName, email, companyName, propertyNames, propertyValues));
}
public JsonResult Update(ContractStatus contractStatus)
{
using (var ContractStatusRepository = _factory.GetRepository <ContractStatus>())
{
return(Json(ContractStatusRepository.Update(contractStatus)));
}
}
public static bool ValidateUpdate(ContractStatus obj, out string errorCode, out string errorMess)
{
errorCode = null;
errorMess = null;
try
{
if (obj == null)
{
errorCode = ErrorCodeEnum.DataInputWrong.ToString();
return(false);
}
if (obj.Name == null)
{
errorCode = ErrorCodeEnum.DataInputWrong.ToString();
errorMess = "Name not allow null value";
return(false);
}
}
catch (Exception ex)
{
Logger.Write(ex.ToString());
throw;
}
return(true);
}
/// <inheritdoc/>
public string ToDelimitedString()
{
CultureInfo culture = CultureInfo.CurrentCulture;
return(string.Format(
culture,
StringHelper.StringFormatSequence(0, 22, Configuration.FieldSeparator),
Id,
ContractIdentifier?.ToDelimitedString(),
ContractDescription,
ContractStatus?.ToDelimitedString(),
EffectiveDate.HasValue ? EffectiveDate.Value.ToString(Consts.DateTimeFormatPrecisionSecond, culture) : null,
ExpirationDate.HasValue ? ExpirationDate.Value.ToString(Consts.DateTimeFormatPrecisionSecond, culture) : null,
ContractOwnerName?.ToDelimitedString(),
ContractOriginatorName?.ToDelimitedString(),
SupplierType?.ToDelimitedString(),
ContractType?.ToDelimitedString(),
FreeOnBoardFreightTerms?.ToDelimitedString(),
PriceProtectionDate.HasValue ? PriceProtectionDate.Value.ToString(Consts.DateTimeFormatPrecisionSecond, culture) : null,
FixedPriceContractIndicator?.ToDelimitedString(),
GroupPurchasingOrganization?.ToDelimitedString(),
MaximumMarkup?.ToDelimitedString(),
ActualMarkup?.ToDelimitedString(),
Corporation != null ? string.Join(Configuration.FieldRepeatSeparator, Corporation.Select(x => x.ToDelimitedString())) : null,
ParentOfCorporation?.ToDelimitedString(),
PricingTierLevel?.ToDelimitedString(),
ContractPriority,
ClassOfTrade?.ToDelimitedString(),
AssociatedContractId?.ToDelimitedString()
).TrimEnd(Configuration.FieldSeparator.ToCharArray()));
}
public LumberContract(LumberResourceQuantity lumber, DevResourceQuantity pay, int deadline, ContractStatus startStatus, ContractDifficulty diff)
{
requiredLumber = lumber;
payout = pay;
completionDeadline = deadline;
status = startStatus;
difficulty = diff;
}
public void WithdrawAsyncTest(HttpStatusCode httpStatusCode, ContractStatus withdrawalType)
{
// Arrange
Mock.Get(_contractsDataLogger)
.Setup(p => p.LogInformation(It.IsAny <string>(), It.IsAny <object[]>()));
if (httpStatusCode != HttpStatusCode.OK)
{
Mock.Get(_contractsDataLogger)
.Setup(p => p.LogError(It.IsAny <ApiGeneralException>(), It.IsAny <string>(), It.IsAny <object[]>()));
}
var expectedContractRequest = new WithdrawalRequest
{
ContractNumber = "Test",
ContractVersion = 1,
FileName = "sample-blob-file.xml",
Id = 1,
WithdrawalType = withdrawalType
};
ContractsDataService contractsDataService = CreateContractsDataService();
SetUpHttpMessageHandler(expectedContractRequest, httpStatusCode, $"/api/contract/withdraw", HttpMethod.Patch);
//Act
Func <Task> action = async() => await contractsDataService.WithdrawAsync(expectedContractRequest);
// Assert
switch (httpStatusCode)
{
case HttpStatusCode.OK:
action.Should().NotThrow();
break;
case HttpStatusCode.BadRequest:
action.Should().Throw <ContractBadRequestClientException>();
break;
case HttpStatusCode.NotFound:
action.Should().Throw <ContractNotFoundClientException>();
break;
case HttpStatusCode.PreconditionFailed:
action.Should().Throw <ContractStatusClientException>();
break;
case HttpStatusCode.Conflict:
action.Should().Throw <ContractUpdateConcurrencyClientException>();
break;
default:
throw new NotImplementedException();
}
_mockHttpMessageHandler.VerifyNoOutstandingExpectation();
VerifyAllMocks();
}
/// <summary>
///
/// </summary>
/// <param name="contractStatus"></param>
/// <param name="pagination"></param>
/// <returns></returns>
public static IList <ServiceContract> FindByContractStatus(ContractStatus contractStatus, Pagination pagination)
{
pagination.AssertNotNull("pagination");
var repository = RepositoryManager.GetRepository <IServiceContractRepository>(ModuleEnvironment.ModuleName);
var list = repository.FindByContractStatus(contractStatus, pagination);
return(list);
}
public Contract(int id, DateTime dateIni, DateTime dateTer, double percCommission, double commission, ContractStatus status)
{
Id = id;
DateIni = dateIni;
DateTer = dateTer;
PercCommission = percCommission;
Commission = commission;
Status = status;
}
public void NewContract_CorrectName_CreatesContract()
{
ContractStatus contractStatus = new ContractStatus();
ContractType contractType = new ContractType();
Contract contract = new Contract(contractStatus, "Conctract1", 10, contractType);
Assert.Equal("Conctract1", contract.ContractTitel);
Assert.Equal(10, contract.Doorlooptijd);
}
public Customer_ContractStatusDTO(ContractStatus ContractStatus)
{
this.Id = ContractStatus.Id;
this.Name = ContractStatus.Name;
this.Code = ContractStatus.Code;
this.Errors = ContractStatus.Errors;
}
public Contract(ContractStatus status, string titel, int doorlooptijd, ContractType contractType)
{
this.ContractStatus = status;
this.ContractTitel = titel;
this.StartDatum = DateTime.Today;
this.EindDatum = StartDatum.AddYears(doorlooptijd);
this.Doorlooptijd = doorlooptijd;
this.ContractType = contractType;
this.Tickets = new List <Ticket>();
}
public async Task <ContractStatus> Get(long Id)
{
ContractStatus ContractStatus = await UOW.ContractStatusRepository.Get(Id);
if (ContractStatus == null)
{
return(null);
}
return(ContractStatus);
}
private void SetupMapper_PublisherAsync(ContractStatus notificationStatus)
{
ContractNotification expectedModel = GetContractNotification();
expectedModel.Status = notificationStatus;
Mock.Get(_mockMapper)
.Setup(m => m.Map <ContractNotification>(It.IsAny <UpdatedContractStatusResponse>()))
.Returns(expectedModel)
.Verifiable();
}
public Company_ContractStatusDTO(ContractStatus ContractStatus)
{
this.Id = ContractStatus.Id;
this.Name = ContractStatus.Name;
this.Code = ContractStatus.Code;
this.Errors = ContractStatus.Errors;
}
public async Task <IActionResult> Create([Bind("Id,Status,Enable")] ContractStatus contractStatus)
{
if (ModelState.IsValid)
{
_context.Add(contractStatus);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(contractStatus));
}
public bool UpdateStatus(ContractStatus status)
{
return DBContract.UpdateStatus(_id, ToString(status));
}
protected static string ToString(ContractStatus status)
{
if ((int)status <= 0)
return string.Empty;
return status.ToString("g").ToLower();
}
public SearchParameters(SearchContractStatusType statusType, ContractStatus contractStatus,
ContractSearchField searchType, string searchValue)
{
this.statusType = statusType;
this.contractStatus = contractStatus;
this.searchType = searchType;
this.searchValue = searchValue;
}
private void SetStatusDependantControls(ContractStatus status)
{
SuspendPhoneUsagePopupButton.Visible = status == ContractStatus.Active && !IsReadOnly;
CloseContractPopupButton.Visible = (status == ContractStatus.Active || status == ContractStatus.Suspended) && !IsReadOnly;
SaveContractButton.Visible = status != ContractStatus.Closed && !IsReadOnly;
}
public static DataSet GetAll(int contractorId, bool isPaidWork, ContractStatus status)
{
return DBContract.GetAll(contractorId, isPaidWork, ToString(status));
}
private static Contract GetContract(ContractStatus status)
{
var contract = new Contract(1, DateTime.Today.AddMonths(-1))
{
ContractNumber = "CT0001",
ContractStatus = status,
AccountId = 1,
PlanId = 1,
ActivationDate = DateTime.Today.AddMonths(-1),
EndDate = DateTime.Today.AddMonths(11),
PhoneNumber1 = "0411331273",
Puk = "1234",
Pin = "1234",
IMEINumber = "123423232345",
SimCard = "123123123123"
};
return contract;
}
public static int UpdateContract(string contractId, int customerId, string accountName,
ContractStatus status, decimal balance, string firstName, string lastName, string email,
string companyName, string propertyNames, string propertyValues)
{
return EcommerceProvider.UpdateContract(contractId, customerId, accountName, (int)status, balance,
firstName, lastName, email, companyName, propertyNames, propertyValues);
}
public Contract(DateTime orderRecievedDate)
{
OrderReceivedDate = orderRecievedDate;
_contractStatus = ContractStatus.NewContract;
StatusChangedDate = orderRecievedDate;
}
