public WalletAddressInfo CreateWallet(string cryptoCode, Guid accountId, AccountTypeEnum accountType, string email = null, string cellphone = null)
{
var url = $"{URL}/Wallet/Create";
_log.Info($"URL--{url}");
var parameters = new
{
CryptoName = cryptoCode,
AccountID = accountId,
AccountType = accountType,
Email = email,
Cellphone = cellphone
};
var paramString = JsonConvert.SerializeObject(parameters);
_log.Info($"Parameters--{paramString}");
var dic = new Dictionary <string, string> {
{ "Authorization", "Bearer " + GenerateToken() }
};
var result = RestUtilities.PostJson(url, dic, paramString);
_log.Info($"Result--{result}");
var data = JsonConvert.DeserializeObject <ServiceResult <WalletAddressInfo> >(result);
if (data.Code == 0)
{
return(data.Data);
}
throw new CommonException(10000, data.Message);
}
internal static Account FindOrAddAccount(ServiceContext context, AccountTypeEnum accountType, AccountClassificationEnum classification)
{
Account typeOfAccount = null;
List <Account> listOfAccount = FindAll <Account>(context, new Account(), 1, 500);
if (listOfAccount.Count > 0)
{
foreach (Account acc in listOfAccount)
{
if (acc.AccountType == accountType && acc.Classification == classification && acc.status != EntityStatusEnum.SyncError)
{
typeOfAccount = acc;
break;
}
}
}
if (typeOfAccount == null)
{
DataService service = new DataService(context);
Account account;
account = QBOHelper.CreateAccount(context, accountType, classification);
account.Classification = classification;
account.AccountType = accountType;
Account createdAccount = service.Add <Account>(account);
typeOfAccount = createdAccount;
}
return(typeOfAccount);
}
public static string CreateAccountNumber(AccountTypeEnum accountType, int contractNumber)
{
long result = contractNumber * 10 % 1_000_000_000;
switch (accountType)
{
case AccountTypeEnum.Cashier:
result += 1010_000_000_000;
break;
case AccountTypeEnum.BankDevelopmentFund:
result += 7327_000_000_000;
break;
case AccountTypeEnum.CurrentAccount:
result += 3014_000_000_000;
break;
case AccountTypeEnum.PercentAccount:
result += 2400_000_000_000;
break;
default:
throw new ArgumentOutOfRangeException(nameof(accountType), accountType, null);
}
result += result.GetDigitSum() % 10;
return(result.ToString());
}
internal Account(AccountTypeEnum accountType, Money initialDeposit)
{
this.accountType = accountType;
ledger = new Ledger(accountType);
this.accountType.ValidateBalance(initialDeposit);
ledger.DepositMoney(initialDeposit);
}
internal Account(AccountTypeEnum accountType, Money initialDeposit)
{
this.accountType = accountType;
ledger = new Ledger(accountType);
this.accountType.ValidateBalance(initialDeposit);
ledger.DepositMoney(initialDeposit);
}
private Account FindOrAddAccount(AccountTypeEnum accountType, AccountClassificationEnum classification)
{
Account typeOfAccount = null;
List <Account> listOfAccount = FindAll <Account>(new Account(), 1, 500);
if (listOfAccount.Count > 0)
{
foreach (Account acc in listOfAccount)
{
if (acc.AccountType == accountType && acc.Classification == classification && acc.status != EntityStatusEnum.SyncError)
{
typeOfAccount = acc;
break;
}
}
}
if (typeOfAccount == null)
{
Account account;
account = CreateAccount(accountType, classification);
account.Classification = classification;
account.AccountType = accountType;
Account createdAccount = dataService.Add <Account>(account);
typeOfAccount = createdAccount;
}
return(typeOfAccount);
}
public AdditionalAmount(AccountTypeEnum accountType, AmountTypeEnum amountType, string currencyCode, double amount)
{
this.AccountType = accountType;
this.AmountType = amountType;
this.CurrencyCode = currencyCode;
this.Amount = amount;
}
public RequiredAccountTypeAttribute(AccountTypeEnum accountType = AccountTypeEnum.Admin)
{
_accountTypeAsStringFormat = new List <string>()
{
((int)accountType).ToString()
};
}
public override ISavingAccount CreateSavingAccount(AccountTypeEnum accountType, string accountNumber)
{
ISavingAccountFactory factory = new SavingAccountFactory();
return(factory.CreateAccount(accountType: accountType
, accountNumber: accountNumber));
}
public static void SetSessionAccountType(AccountTypeEnum type)
{
WeixinAccountIdentity wai = accountIdentity;
wai.type = type;
accountIdentity = wai;
}
/// <summary>
/// Initializes a new instance of the <see cref="ContactAttributes" /> class.
/// </summary>
/// <param name="email">E-posta.</param>
/// <param name="name">Müşteri/tedarikçi ismi (required).</param>
/// <param name="shortName">shortName.</param>
/// <param name="contactType">Tip.</param>
/// <param name="taxOffice">Vergi dairesi.</param>
/// <param name="taxNumber">Vergi numarası/TC kimlik no.</param>
/// <param name="district">İlçe.</param>
/// <param name="city">İl.</param>
/// <param name="address">address.</param>
/// <param name="phone">phone.</param>
/// <param name="fax">fax.</param>
/// <param name="isAbroad">isAbroad.</param>
/// <param name="archived">archived.</param>
/// <param name="iban">iban.</param>
/// <param name="accountType">accountType (required).</param>
public ContactAttributes(string email = default(string), string name = default(string), string shortName = default(string), ContactTypeEnum?contactType = default(ContactTypeEnum?), string taxOffice = default(string), string taxNumber = default(string), string district = default(string), string city = default(string), string address = default(string), string phone = default(string), string fax = default(string), bool?isAbroad = default(bool?), bool?archived = default(bool?), string iban = default(string), AccountTypeEnum accountType = default(AccountTypeEnum))
{
// to ensure "name" is required (not null)
if (name == null)
{
throw new InvalidDataException("name is a required property for ContactAttributes and cannot be null");
}
else
{
this.Name = name;
}
// to ensure "accountType" is required (not null)
if (accountType == null)
{
throw new InvalidDataException("accountType is a required property for ContactAttributes and cannot be null");
}
else
{
this.AccountType = accountType;
}
this.Email = email;
this.ShortName = shortName;
this.ContactType = contactType;
this.TaxOffice = taxOffice;
this.TaxNumber = taxNumber;
this.District = district;
this.City = city;
this.Address = address;
this.Phone = phone;
this.Fax = fax;
this.IsAbroad = isAbroad;
this.Archived = archived;
this.Iban = iban;
}
public void Update(string accountHolderName, string bankName, string bankCode, string accountNumber, AccountTypeEnum accountType)
{
AccountHolderName = accountHolderName;
BankName = bankName;
BankCode = bankCode;
AccountNumber = accountNumber;
AccountType = accountType;
}
IList <Account> FindByType(AccountTypeEnum type)
{
IQuery query = NHibernateHelper.OpenSession().CreateQuery("from Account where type = :type and inactive = :inactive order by type, name");
query.SetInt32("type", (int)type);
query.SetBoolean("inactive", false);
return(query.List <Account>());
}
private void InitStrings(string tranType, string fromAccount, string toAccount)
{
this.TransactionType = EFTProperties <TransactionTypeEnum> .Enum(tranType);
this.FromAccount = EFTProperties <AccountTypeEnum> .Enum(fromAccount);
this.ToAccount = EFTProperties <AccountTypeEnum> .Enum(toAccount);
}
public Customer FindByExternalId(string externalId, AccountTypeEnum accountTypeEnum)
{
var criteria = DetachedCriteria.For(typeof(Customer))
.Add(Restrictions.Eq("ExternalId", externalId.Trim()))
.Add(Restrictions.Eq("AccountType", accountTypeEnum));
return CustomerRepo.FindOne(criteria);
}
public VendorBankDetail(string accountHolderName, string bankName, string bankCode, string accountNumber, AccountTypeEnum accountType)
{
AccountHolderName = accountHolderName;
BankName = bankName;
BankCode = bankCode;
AccountNumber = accountNumber;
AccountType = accountType;
}
public Account OpenAccount(AccountTypeEnum accountType, decimal initialDeposit)
{
if (GetCurrentAge() < 18)
{
throw new InvalidOperationException("Must be older than 18 to open an account");
}
return(new Account(accountType, initialDeposit));
}
public Account OpenAccount(AccountTypeEnum accountType, Money initialDeposit)
{
if (dateOfBirth.GetCurrentAge() < 18)
{
throw new InvalidOperationException("Must be older than 18 to open an account");
}
return new Account(accountType, initialDeposit);
}
private void CreateAccountAddress(
IOrganizationService organizationService
, ITracingService tracingService
, Guid accountId
, AccountKonturFocusModel accountData
, AccountTypeEnum accountType
, AddressTypeEnum addressType
)
{
tracingService.Trace("enter konturfocussynchronizationplugin.createaccountaddress");
ParsedAddressRF addressObj = null;
if (accountData.UL != null)
{
addressObj = accountData.UL.legalAddress?.parsedAddressRF;
}
if (accountData.IP != null)
{
addressObj = accountData.IP.legalAddress?.parsedAddressRF;
}
if (addressObj == null)
{
if (accountType == AccountTypeEnum.IP && accountData != null)
{
ParsedAddressRF shortenedAddress = accountData.IP?.shortenedAddress;
if (shortenedAddress == null)
{
return;
}
addressObj = shortenedAddress;
}
else
{
return;
}
}
CustomerAddress customerAddress = new CustomerAddress
{
Line1 = GetAddressLine(addressObj, accountData, accountType, addressType, tracingService),
ParentId = new EntityReference(Account.EntityLogicalName, accountId)
};
customerAddress.Id = organizationService.Create(customerAddress);
Account account = new Account
{
Id = accountId
};
FillAddress(account, tracingService, accountData, accountType, addressType);
organizationService.Update(account);
tracingService.Trace("exit konturfocussynchronizationplugin.createaccountaddress");
}
public Account(string number, string bank, string branch, float amount, string ifscCode, AccountTypeEnum typeEnum)
{
AccountNumber = number;
Bank = bank;
Branch = branch;
Amount = amount;
IfscCode = ifscCode;
TypeEnum = typeEnum;
}
public Account(Session session, int credit, AccountTypeEnum type, string name, string code) : this(session)
{
this.Customer = null;
Credit = credit;
Debit = 0;
Balance = Credit - Debit;
Name = name;
Type = type;
}
public AccountType(AccountTypeEnum accountType)
: this()
{
if (accountType == AccountTypeEnum.Unknown)
{
throw new InvalidOperationException("Please specifiy a valid account type");
}
this.accountType = accountType;
}
/// <summary>
/// Internal ctor - to construct object with all properties.
/// Initializes a new instance of the <see cref="Account" /> class.
/// </summary>
/// <param name="type">The account type.</param>
/// <param name="id">The account identifier.</param>
/// <param name="bankId">The bank identifier.</param>
/// <param name="description">The description.</param>
/// <param name="phone">The phone.</param>
/// <param name="subType">Type of the sub.</param>
/// <param name="status">The status.</param>
internal Account(AccountTypeEnum type, string id, string bankId, string description, string phone, string subType, string status)
{
Status = status;
SubType = subType;
Description = description;
BankId = bankId;
Id = id;
Type = type;
Phone = phone;
}
public async Task <Account> GetAccountWithType(AccountTypeEnum accountType)
{
await using var context = ContextFactory.CreateDbContext();
var entity = await context.Set <Account>()
.Include(x => x.AccountType)
.FirstOrDefaultAsync(x => x.AccountType.Name == accountType)
.ConfigureAwait(false);
return(entity);
}
public IAccount CreateInstance(AccountTypeEnum accountToCreate)
{
Type t = GetAccountType(accountToCreate);
if (t == null)
{
return(null); //TODO: implement NULL object pattern
}
return(Activator.CreateInstance(t) as IAccount);
}
private Account CreateAccount(AccountTypeEnum accountType, AccountClassificationEnum classification)
{
//Note: Have not removed comments because it will help in understanding the parameters.
//
Account account = new Account();
String guid = Guid.NewGuid().ToString("N");
account.Name = "Name_" + guid;
//account.SubAccount = true;
//account.SubAccountSpecified = true;
//account.ParentRef = new ReferenceType()
//{
//name =
//type =
//Value =
//};
//account.Description = "Description";
account.FullyQualifiedName = account.Name;
//account.Active = true;
//account.ActiveSpecified = true;
account.Classification = classification;
account.ClassificationSpecified = true;
account.AccountType = accountType;
account.AccountTypeSpecified = true;
//account.AccountSubType = "AccountSubType";
//account.AcctNum = "AcctNum";
//account.BankNum = "BankNum";
if (accountType != AccountTypeEnum.Expense && accountType != AccountTypeEnum.AccountsPayable && accountType != AccountTypeEnum.AccountsReceivable)
{
//TestComment: Opening Balances not working for QBO Item tests
//account.OpeningBalance = new Decimal(100.00);
//account.OpeningBalanceSpecified = true;
//account.OpeningBalanceDate = DateTime.UtcNow.Date;
//account.OpeningBalanceDateSpecified = true;
}
//account.CurrentBalance = new Decimal(100.00);
//account.CurrentBalanceSpecified = true;
//account.CurrentBalanceWithSubAccounts = new Decimal(100.00);
//account.CurrentBalanceWithSubAccountsSpecified = true;
account.CurrencyRef = new ReferenceType()
{
name = "United States Dollar",
Value = "USD"
};
//account.TaxAccount = true;
//account.TaxAccountSpecified = true;
//account.TaxCodeRef = new ReferenceType()
//{
//name =
//type =
//Value =
//};
//account.AccountEx =
return(account);
}
private Type GetAccountType(AccountTypeEnum accountToCreate)
{
foreach (var acct in _accounts)
{
if (acct.Key.Contains(accountToCreate.ToString().ToLower()))
{
return(_accounts[acct.Key]);
}
}
return(null);
}
public AccountBag(DataContext dataContext, AccountTypeEnum accountType)
{
// AccountType = accountType;
Account = new Entity.account
{
AccountID = dataContext.UserId + DateTime.Now.Random().ToString(),
Balance = 0,
LastUpdateTime = DateTime.Now,
AccType = accountType.ToString()
};
}
public AccountBag(string accountId, AccountTypeEnum accountType)
{
// AccountType = accountType;
Account = new Entity.account
{
AccountID = accountId,
Balance = 0,
LastUpdateTime = DateTime.Now,
AccType = accountType.ToString()
};
}
internal Account(AccountTypeEnum accountType, decimal initialDeposit)
{
if (accountType == AccountTypeEnum.Unknown)
{
throw new InvalidOperationException("Please specifiy a valid account type");
}
this.accountType = accountType;
ledger = new Ledger(accountType);
ValidateBalance(initialDeposit);
ledger.DepositMoney(initialDeposit);
}
internal Account(AccountTypeEnum accountType, decimal initialDeposit)
{
if (accountType == AccountTypeEnum.Unknown)
{
throw new InvalidOperationException("Please specifiy a valid account type");
}
this.accountType = accountType;
ledger = new Ledger(accountType);
ValidateBalance(initialDeposit);
ledger.DepositMoney(initialDeposit);
}
public AccountInfo(string userid,
string lastname,
string firstname,
string middlename,
AccountTypeEnum accounttype,
Image avatar)
{
UserId = userid;
Lastname = lastname;
Firstname = firstname;
Middlename = middlename;
AccountType = accounttype;
Avatar = avatar;
}
public static string GetString(AccountTypeEnum state)
{
switch (state)
{
case AccountTypeEnum.Admin: return(AccountRes.ACCOUNT_TYPE_ADMIN);
case AccountTypeEnum.Payed: return(AccountRes.ACCOUNT_TYPE_PAYING);
case AccountTypeEnum.Standard: return(AccountRes.ACCOUNT_TYPE_STANDARD);
case AccountTypeEnum.Demo: return(AccountRes.ACCOUNT_TYPE_DEMO);
}
return(null);
}
internal static Account QueryOrAddAccount(DataService dataService, QueryService <Account> queryService,
string query, AccountTypeEnum accountType, AccountClassificationEnum classification,
AccountSubTypeEnum subType)
{
var queryResponse = queryService.ExecuteIdsQuery(query).ToList();
if (queryResponse.Count == 0)
{
var account = AccountCreate(dataService, accountType, classification, subType);
return(account);
}
return(queryResponse[0]);
}
internal Ledger(AccountTypeEnum accountType)
{
transactions = new HashSet<Transaction>();
this.accountType = accountType;
}
