/// <summary>
/// 删除冲帐记录数据
/// </summary>
/// <param name="nId"></param>
/// <param name="nOpStaffId"></param>
/// <param name="strOpStaffName"></param>
/// <param name="strErrText"></param>
/// <returns></returns>
public bool DeleteContractReverse(long nId, long nOpStaffId, string strOpStaffName, out string strErrText)
{
try
{
using (TransactionScope transScope = new TransactionScope(TransactionScopeOption.Required, new TimeSpan(2, 0, 0)))
{
using (ContractDAO dao = new ContractDAO())
{
if (!dao.DeleteContractReverse(nId, nOpStaffId, strOpStaffName, out strErrText))
{
return(false);
}
if (!dao.DeleteContractReverseDetails(nId, nOpStaffId, strOpStaffName, out strErrText))
{
return(false);
}
}
transScope.Complete();
}
return(true);
}
catch (Exception e)
{
strErrText = e.Message;
return(false);
}
}
public async Task <int> CreateCheck(string fromAddress, string ToAddress, DateTime CheckDate, uint Amount)
{
_account = _account ?? _web3Backend.GetAccount(fromAddress);
_web3 = _web3 ?? _web3Backend.GetWeb3(_account);
_checkcontract = _checkcontract ??
await _contracts.GetContract("PostdatedCheckManager",
_config.GetSection("NetworkId").Value);
CheckModels.CreateCheckInputFunction inputFunc = new CheckModels.CreateCheckInputFunction()
{
FromAddress = fromAddress,
To = ToAddress,
Amount = Amount,
CheckDate = CheckDate.ToUnixTimestampTicks()
};
var handler = _web3.Eth.GetContractTransactionHandler <CheckModels.CreateCheckInputFunction>();
var result =
await handler.SendRequestAndWaitForReceiptAsync(_checkcontract.Address, inputFunc);
var logResult = await CreatedLastCheck(fromAddress);
return(logResult.CheckId);
}
public static string GetContractModelName(string contractModelCode)
{
string text2;
try
{
string text = "";
if (contractModelCode == "")
{
return(text);
}
EntityData contractModelByCode = ContractDAO.GetContractModelByCode(contractModelCode);
if (contractModelByCode.HasRecord())
{
text = contractModelByCode.GetString("ContractModelName");
}
contractModelByCode.Dispose();
text2 = text;
}
catch (Exception exception)
{
throw exception;
}
return(text2);
}
public async Task <bool> IsCheckCustomer(string CustomerId)
{
_account = _account ?? _web3Backend.GetDefaultAccount();
_web3 = _web3 ?? _web3Backend.GetDefaultWeb3();
var address = await _walletService.GetWalletAdress(CustomerId);
var addr = address?.RemoveHexPrefix().Trim('0');
if (string.IsNullOrEmpty(addr))
{
return(false);
}
_checkcontract = _checkcontract ??
await _contracts.GetContract("PostdatedCheckManager",
_config.GetSection("NetworkId").Value);
CheckModels.IsCustomerInputFunction inputFunc = new CheckModels.IsCustomerInputFunction()
{
Address = address,
FromAddress = _account.Address
};
var handler = _web3.Eth.GetContractQueryHandler <CheckModels.IsCustomerInputFunction>();
var result =
await handler.QueryDeserializingToObjectAsync <CheckModels.IsCustomerOutputModel>(inputFunc,
_checkcontract.Address);
return(await Task.FromResult(result.IsCustomer));
}
private static Boolean AreContractsActive(DataConnector connector, MailingDTO mailing)
{
Boolean active;
ContractDAO contractDAO = new ContractDAO(connector.MySqlConnection);
ContractItemDAO contractItemDAO = new ContractItemDAO(connector.MySqlConnection);
// Faturamento de um contrato apenas
if (mailing.codigoContrato != 0)
{
ContractDTO contract = contractDAO.GetContract(mailing.codigoContrato);
active = (contract.status != 3) && (contract.status != 4);
return(active);
}
// Caso contrário é o faturamento de todos os equipamentos do cliente (um ou mais contratos)
active = false;
List <ContractItemDTO> itemList = contractItemDAO.GetItems("businessPartnerCode = '" + mailing.businessPartnerCode + "'");
foreach (ContractItemDTO item in itemList)
{
ContractDTO contract = contractDAO.GetContract(item.contrato_id);
if ((contract.status != 3) && (contract.status != 4))
{
active = true;
}
}
return(active);
}
/// <summary>
/// 合同罚款处理
/// </summary>
/// <param name="listContract"></param>
/// <param name="nOpStaffId"></param>
/// <param name="strOpStaffName"></param>
/// <param name="strErrText"></param>
/// <returns></returns>
public bool FineContracts(List <Contract> listContract, long nOpStaffId, string strOpStaffName, out string strErrText)
{
strErrText = string.Empty;
try
{
using (TransactionScope transScope = new TransactionScope(TransactionScopeOption.Required, new TimeSpan(2, 0, 0)))
{
using (ContractDAO dao = new ContractDAO())
{
//修改合同罚款金额数据
foreach (Contract contract in listContract)
{
if (!dao.UpdateContractFineAmount(contract.Id, contract.FineAmount, nOpStaffId, strOpStaffName, out strErrText))
{
return(false);
}
}
}
transScope.Complete();
}
return(true);
}
catch (Exception e)
{
strErrText = e.Message;
return(false);
}
}
public IEnumerable <NormalContract> LastestFromCustomer(int userId, int quantity)
{
ContractDAO contractDao = new ContractDAO(connectionString);
IEnumerable <NormalContract> normalContracts = contractDao.LastestFromCustomer(userId, quantity);
return(normalContracts);
}
public MasterContract InactivateMasterContract(int masterContractId, int userId)
{
ContractDAO contractDao = new ContractDAO(connectionString);
MasterContract result = contractDao.InactivateMasterContract(masterContractId, userId);
return(result);
}
public IEnumerable <NormalContractItem> DocumentFlow(int contractId)
{
ContractDAO contractDao = new ContractDAO(connectionString);
IEnumerable <NormalContractItem> normalContractItems = contractDao.DocumentFlow(contractId);
return(normalContractItems);
}
public MasterContract GetMasterContract(int masterContractId)
{
ContractDAO contractDAO = new ContractDAO(connectionString);
MasterContract masterContract = contractDAO.GetMasterContract(masterContractId);
return(masterContract);
}
private void btnSave_Click(object sender, EventArgs e)
{
DataSet ds = new DataSet();
try
{
ContractDTO obj = new ContractDTO();
obj.IDHouse = Convert.ToInt64((cboHouse.SelectedItem as clsComboItem).Value);
obj.IDCustomer = Convert.ToInt64((cboCustomer.SelectedItem as clsComboItem).Value);
obj.IDEmployee = Convert.ToInt64((cboEmployee.SelectedItem as clsComboItem).Value);
ds = ContractDAO.Contract_InsUpd(obj);
if (ds != null && ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0 && Convert.ToInt32(ds.Tables[0].Rows[0]["Result"]) == 1)
{
clsMessages.ShowInformation("Thêm thành công!");
frmParent.LoadDataToForm();
this.Close();
}
else
{
clsMessages.ShowWarning("Thêm thất bại!");
}
}
catch (Exception ex)
{
clsMessages.ShowErrorException(ex);
}
finally
{
ds.Dispose();
}
}
public SearchResult SearchContractsFromCustomer(int userId, string term, int pageSize, int page)
{
ContractDAO contractDao = new ContractDAO(connectionString);
SearchResult searchResult = contractDao.SearchContractsFromCustomer(userId, term, pageSize, page);
searchResult.PageSize = pageSize;
return(searchResult);
}
public SearchResult SearchMasterContracts(int salesUserId, int pageSize, int page)
{
ContractDAO contractDAO = new ContractDAO(connectionString);
SearchResult result = contractDAO.SearchMasterContracts(salesUserId, pageSize, page);
result.PageSize = pageSize;
return(result);
}
public Result SetNormalContractSentToSAP(NormalContract normalContract, string SAPNumber)
{
ContractDAO contractDAO = new ContractDAO(connectionString);
SAPNumber = SAPNumber.PadLeft(10, '0');
Result result = contractDAO.SetNormalContractSentToSAP(normalContract, SAPNumber);
return(result);
}
private void btnPrint_Click(object sender, EventArgs e)
{
if (contract != null)
{
frmPrintContract frmPC = new frmPrintContract();
ContractReportViewModel contractView = new ContractDAO().GetForReport(contract.ContractID);
frmPC.InitContract(contractView);
frmPC.ShowDialog();
}
}
public async Task <ContractDAO> GetContractFromJson(string contractName, string networkID)
{
var contractFile = $"{Constants.CONTRACT_ARTIFACTS_DIR_NAME}/{contractName}.json";
JObject contractOjb = JObject.Parse(File.ReadAllText(contractFile));
ContractDAO dao = new ContractDAO()
{
Abi = contractOjb.GetValue("abi").ToString(),
Address = contractOjb.GetValue("networks")[networkID]["address"].ToString()
};
return(await Task.FromResult(dao));
}
public async Task <ContractDAO> GetContract(string contractName, string networkID)
{
List <ContractDAO> contractList = null;
if (!Cache.TryGetValue(Constants.CACHE_CONTRACT_LIST, out contractList))
{
contractList = new List <ContractDAO>();
Cache.Set(Constants.CACHE_CONTRACT_LIST, contractList);
}
var cachedContract = contractList.Where(x => x.Name.Equals(contractName));
if (cachedContract.Any())
{
return(cachedContract.SingleOrDefault());
}
ContractDAO contractJson = null;
try
{
contractJson = await GetContractFromJson(contractName, networkID);
}
catch (ArgumentNullException ex)
{
Logger.LogError(ex.Message);
return(null);
}
catch (ArgumentException ex)
{
Logger.LogTrace(ex.Message);
return(null);
}
var url = Config.GetSection(Constants.GETH_RPC).Value;
var web3 = new Web3(url);
var contract = await Task.Run(() => web3.Eth.GetContract(contractJson.Abi, contractJson.Address));
var contDAO = new ContractDAO()
{
Contract = contract,
Name = contractName,
Address = contract.Address,
CodeHash = contract.Eth.GetCode.ToString(),
StorageHash = contract.Eth.GetStorageAt.ToString(),
Abi = contractJson.Address
};
contractList.Add(contDAO);
Cache.Set(Constants.CACHE_CONTRACT_LIST, contractList);
return(contDAO);
}
public Facade()
{
_contingencyFundDAO = FactoryDAO.CreateContigencyFundDAO();
_monetaryFundDAO = FactoryDAO.CreateMonetaryFundDAO();
_extraFundDAO = FactoryDAO.CreateExtraFundDAO();
_employeeDAO = FactoryDAO.CreateEmployeeDAO();
_roleDAO = FactoryDAO.CreateRoleDAO();
_bankDAO = FactoryDAO.CreateBankDAO();
_departmentDAO = FactoryDAO.CreateDepartmentDAO();
_contractDAO = FactoryDAO.CreateContractDAO();
_employeeHistoryDAO = FactoryDAO.CreateEmployeeHistoryDAO();
_contingencyPastDAO = FactoryDAO.CreateContigencyPastDAO();
_contingencyAliquotDAO = FactoryDAO.createContingencyAliquotDAO();
}
private static String ObterParcelaContrato(DataConnector connector, ContractDTO contract)
{
// Grava a parcela atual, adiciona uma parcela pois está iniciando um novo faturamento
ContractDAO contractDAO = new ContractDAO(connector.MySqlConnection);
int increase = 0;
if ((contract.mesReferencia != DateTime.Now.Month))
{
increase = 1;
contractDAO.SetContractParcell(contract.id, contract.parcelaAtual + increase);
contractDAO.SetContractMonthYear(contract.id, DateTime.Now.Month, DateTime.Now.Year);
}
return((contract.parcelaAtual + increase) + "/" + contract.quantidadeParcelas);
}
/// <summary>
/// Generates the PO Number and creates the cadence data in
/// MOL database to avoid dump in ZSDI3003_CONTRACT_CREATE.
/// </summary>
/// <param name="contract">The contract generated from Master Contract Items.</param>
public NormalContract GenerateAndSaveNormalContractAndItems(NormalContract normalContract)
{
ContractDAO contractDAO = new ContractDAO(connectionString);
NormalContract savedNormalContract = contractDAO.GenerateNormalContract(normalContract);
foreach (NormalContractItem normalContractItem in normalContract.NormalContractItems)
{
normalContractItem.ContractId = savedNormalContract.Id;
NormalContractItem savedNormalContractItem = contractDAO.InsertNormalContractItem(normalContractItem, normalContract.StartDate.Value, normalContract.CreationUser);
savedNormalContractItem.Incoterms = normalContractItem.Incoterms;
savedNormalContractItem.Region = normalContractItem.Region;
savedNormalContract.NormalContractItems.Add(savedNormalContractItem);
}
return(savedNormalContract);
}
/// <summary>
/// 新增合同数据
/// </summary>
/// <param name="data"></param>
/// <param name="listPlan"></param>
/// <param name="nOpStaffId"></param>
/// <param name="strOpStaffName"></param>
/// <param name="strErrText"></param>
/// <returns></returns>
public long InsertContract(Contract data, List <ContractDeliverPlan> listPlan, long nOpStaffId, string strOpStaffName, out string strErrText)
{
long nContractId = 0;
try
{
using (TransactionScope transScope = new TransactionScope(TransactionScopeOption.Required, new TimeSpan(2, 0, 0)))
{
using (ContractDAO dao = new ContractDAO())
{
//新增合同数据
nContractId = dao.InsertContract(data, nOpStaffId, strOpStaffName, out strErrText);
if (nContractId <= 0)
{
return(0);
}
//新增合同计划数据
foreach (ContractDeliverPlan plan in listPlan)
{
plan.ContractId = nContractId;
if (!dao.InsertContractDeliverPlan(plan, nOpStaffId, strOpStaffName, out strErrText))
{
return(0);
}
}
}
using (DispatchDAO dao = new DispatchDAO())
{
//检查调度单数据
if (!dao.CheckDispatchBill(data.DispatchBillId, nOpStaffId, strOpStaffName, out strErrText))
{
return(0);
}
}
transScope.Complete();
}
return(nContractId);
}
catch (Exception e)
{
strErrText = e.Message;
return(0);
}
}
public async Task <CheckModels.CreateCheckEventDTO> CreatedLastCheck(string fromAddress)
{
_web3 = _web3 ?? _web3Backend.GetDefaultWeb3();
_checkcontract = _checkcontract ??
await _contracts.GetContract("PostdatedCheckManager",
_config.GetSection("NetworkId").Value);
var eventHandler = _web3.Eth.GetEvent <CheckModels.CreateCheckEventDTO>(_checkcontract.Address);
var filter = eventHandler.CreateFilterInput(BlockParameter.CreateLatest(), BlockParameter.CreateLatest());
var results = await eventHandler.GetAllChanges(filter);
var lastEvent = results?.First().Event;
return(lastEvent);
}
public async Task <bool> AddCheckCustomer(string CustomerId)
{
var ischeckCustomer = await IsCheckCustomer(CustomerId);
if (ischeckCustomer)
{
return(true);
}
_account = _account ?? _web3Backend.GetDefaultAccount();
_web3 = _web3 ?? _web3Backend.GetDefaultWeb3();
var address = await _walletService.GetWalletAdress(CustomerId);
var addr = address?.RemoveHexPrefix().Trim('0');
if (string.IsNullOrEmpty(addr))
{
address = await _walletService.CreateAndAddAdressToWallet(CustomerId);
}
_checkcontract = _checkcontract ??
await _contracts.GetContract("PostdatedCheckManager",
_config.GetSection("NetworkId").Value);
CheckModels.AddCustomerInputFunction inputFunc = new CheckModels.AddCustomerInputFunction()
{
Address = address,
FromAddress = _account.Address
};
var handler = _web3.Eth.GetContractTransactionHandler <CheckModels.AddCustomerInputFunction>();
var result =
await handler.SendRequestAndWaitForReceiptAsync(_checkcontract.Address, inputFunc);
if (result.Status == BigInteger.One)
{
return(await Task.FromResult(true));
}
else
{
return(await Task.FromResult(false));
}
}
public SendToSAPResult ResendNormalContractToSAP(int normalContractId)
{
ContractDAO contractDAO = new ContractDAO(connectionString);
NormalContract normalContract = contractDAO.GetNormalContractWithMaster(normalContractId);
List <Result> results = SendNormalContractToSAP(normalContract);
var resultsWithFailures = from contractResult in results
where contractResult.Success == false
select contractResult;
SendToSAPResult sendToSAPResult = new SendToSAPResult
{
NormalContract = normalContract,
Payload = results,
Success = (resultsWithFailures.Count() == 0)
};
return(sendToSAPResult);
}
public async Task <CheckModels.CheckInfoOutputModel> CheckInfo(string fromAddress, long checkId)
{
_account = _account ?? _web3Backend.GetAccount(fromAddress);
_web3 = _web3 ?? _web3Backend.GetWeb3(_account);
_checkcontract = _checkcontract ??
await _contracts.GetContract("PostdatedCheckManager",
_config.GetSection("NetworkId").Value);
CheckModels.CheckInfoInputFunction inputFunc = new CheckModels.CheckInfoInputFunction()
{
FromAddress = fromAddress,
TokenId = checkId
};
var handler = _web3.Eth.GetContractQueryHandler <CheckModels.CheckInfoInputFunction>();
var result =
await handler.QueryDeserializingToObjectAsync <CheckModels.CheckInfoOutputModel>(inputFunc, _checkcontract.Address);
return(result);
}
public async Task <string> CreateAndAddAdressToWallet(string CustomerId)
{
_account = _account ?? _web3Backend.GetDefaultAccount();
_web3 = _web3 ?? _web3Backend.GetDefaultWeb3();
_walletcontract = _walletcontract ?? await _contracts.GetContract("Wallet", _config.GetSection("NetworkId").Value);
var newAccount = await _web3.Personal.NewAccount.SendRequestAsync("");
/*
* var ecKey = Nethereum.Signer.EthECKey.GenerateKey();
* var privateKey = ecKey.GetPrivateKeyAsBytes().ToHex();
* var newAccount = (new Nethereum.Web3.Accounts.Account(privateKey)).Address;
*/
AddToWalletInputFunction func = new AddToWalletInputFunction()
{
customerId = CustomerId,
FromAddress = _account.Address,
newAccount = newAccount,
Gas = Constants.DEFAULT_GAS,
GasPrice = Constants.DEFAULT_GAS_PRICE
};
var addtowalletHandler = _web3.Eth.GetContractTransactionHandler <AddToWalletInputFunction>();
var addtoWalletResult =
await addtowalletHandler.SendRequestAndWaitForReceiptAsync(_walletcontract.Address, func);
if (addtoWalletResult.Status == BigInteger.One)
{
var transferEther =
await _web3.TransactionManager.TransactionReceiptService.SendRequestAndWaitForReceiptAsync(
new TransactionInput()
{
From = _account.Address, To = newAccount, Value = new HexBigInteger(1000000000000000000)
},
null);
}
return(await Task.FromResult(newAccount));
}
/// <summary>
/// 合同退回修改
/// </summary>
/// <param name="nId"></param>
/// <param name="nOpStaffId"></param>
/// <param name="strOpStaffName"></param>
/// <param name="strErrText"></param>
/// <returns></returns>
public bool ReturnModifyContract(long nId, long nOpStaffId, string strOpStaffName, out string strErrText)
{
try
{
using (TransactionScope transScope = new TransactionScope(TransactionScopeOption.Required, new TimeSpan(2, 0, 0)))
{
//修改合同数据
Contract data = null;
using (ContractDAO dao = new ContractDAO())
{
data = dao.LoadContract(nId, nOpStaffId, strOpStaffName, out strErrText);
if (data == null)
{
return(false);
}
if (!dao.ReturnModifyContract(nId, nOpStaffId, strOpStaffName, out strErrText))
{
return(false);
}
}
//检查调度单数据
using (DispatchDAO dao = new DispatchDAO())
{
if (!dao.CheckDispatchBill(data.DispatchBillId, nOpStaffId, strOpStaffName, out strErrText))
{
return(false);
}
}
transScope.Complete();
}
return(true);
}
catch (Exception e)
{
strErrText = e.Message;
return(false);
}
}
/// <summary>
/// 修改合同发货数据
/// </summary>
/// <param name="data"></param>
/// <param name="listGoods"></param>
/// <param name="nOpStaffId"></param>
/// <param name="strOpStaffName"></param>
/// <param name="strErrText"></param>
/// <returns></returns>
public bool UpdateContractDeliverPlan(ContractDeliverPlan data, List <ContractGoods> listGoods, long nOpStaffId, string strOpStaffName, out string strErrText)
{
try
{
using (TransactionScope transScope = new TransactionScope(TransactionScopeOption.Required, new TimeSpan(2, 0, 0)))
{
using (ContractDAO dao = new ContractDAO())
{
if (!dao.UpdateContractDeliverPlan(data, nOpStaffId, strOpStaffName, out strErrText))
{
return(false);
}
foreach (ContractGoods goods in listGoods)
{
if (!dao.UpdateContractGoods(goods, nOpStaffId, strOpStaffName, out strErrText))
{
return(false);
}
}
}
using (DispatchDAO dao = new DispatchDAO())
{
//检查调度单数据
if (!dao.CheckDispatchBill(data.DispatchBillId, nOpStaffId, strOpStaffName, out strErrText))
{
return(false);
}
}
transScope.Complete();
}
return(true);
}
catch (Exception e)
{
strErrText = e.Message;
return(false);
}
}
public async Task <List <Check> > CheckListCreated(string fromAddress)
{
_account = _account ?? _web3Backend.GetAccount(fromAddress);
_web3 = _web3 ?? _web3Backend.GetWeb3(_account);
_checkcontract = _checkcontract ??
await _contracts.GetContract("PostdatedCheckManager",
_config.GetSection("NetworkId").Value);
CheckModels.CheckListCreatedInputFunction inputFunc = new CheckModels.CheckListCreatedInputFunction()
{
FromAddress = fromAddress,
Address = fromAddress
};
var handler = _web3.Eth.GetContractQueryHandler <CheckModels.CheckListCreatedInputFunction>();
var result =
await handler.QueryDeserializingToObjectAsync <CheckModels.CheckListOutputModel>(inputFunc, _checkcontract.Address);
var response = new List <Check>();
var list = result?.CheckList;
foreach (var item in list)
{
var checkinfo = await CheckInfo(fromAddress, item);
if (checkinfo != null)
{
response.Add(new Check()
{
Amount = checkinfo.Amount,
CheckDate = TimeHelper.UnixTimestampToDateTime(checkinfo.CheckDate),
Creator = checkinfo.Creator,
Owner = checkinfo.Owner
});
}
}
return(response);
}
public List <NormalContract> CheckNormalContractsFromMasterContract(int masterContractId)
{
List <NormalContract> contractsNotFound = new List <NormalContract>();
ContractDAO contractDAO = new ContractDAO(connectionString);
MasterContract masterContract = contractDAO.GetMasterContract(masterContractId);
this.MakeContractsFromMasterItems(masterContract);
List <NormalContract> normalContractsThatShouldExist = this.MakeContractsFromMasterItems(masterContract);
foreach (NormalContract normalContractThatShouldExist in normalContractsThatShouldExist)
{
IEnumerable <NormalContract> contractsFound = from existingNormalContract in masterContract.NormalContracts
where existingNormalContract.StartDate == normalContractThatShouldExist.StartDate && existingNormalContract.EndDate == normalContractThatShouldExist.EndDate
select existingNormalContract;
if (contractsFound.Count() == 0)
{
contractsNotFound.Add(normalContractThatShouldExist);
continue;
}
else
{
foreach (NormalContractItem itemThatShouldExist in normalContractThatShouldExist.NormalContractItems)
{
IEnumerable <NormalContractItem> itemsFound = from existingNormalContract in contractsFound
from existingItem in existingNormalContract.NormalContractItems
where existingItem.Material.Id == itemThatShouldExist.Material.Id && existingItem.Quantity == itemThatShouldExist.Quantity
select existingItem;
if (itemsFound.Count() == 0)
{
contractsNotFound.Add(normalContractThatShouldExist);
continue;
}
}
}
}
return(contractsNotFound);
}
