/// <summary>
/// Получить список сохраненных КИ клиента по коду анкеты асинхронно.
/// </summary>
/// <param name="creditHistoryID">Код анкеты в базе</param>
/// <param name="cancellationToken">Токен отмены</param>
/// <returns>Список сохраненных КИ</returns>
public async Task <CreditHistoryInfo[]> GetCreditHistoryListByCreditHistoryIDAsync(int creditHistoryID,
CancellationToken cancellationToken)
{
GetCreditHistoryListByCreditHistoryIDCheckParams(creditHistoryID);
int clientID = (await GetCreditHistoryByIDAsync(creditHistoryID, cancellationToken))?.ID ?? default;
if (clientID == default)
{
return(new CreditHistoryInfo[0]);
}
using (IDBSource dbSource = new MKKContext()) {
return(await dbSource.CreditHistories.
AsNoTracking().
Where(i => i.Client.ID == clientID).
Select(i => new CreditHistoryInfo()
{
CreditHistoryID = i.ID,
Date = i.Date,
ErrorText = i.ErrorText,
ErrorCode = i.ErrorCode
}).
OrderByDescending(o => o.Date).
ToArrayAndLogErrorAsync <CreditHistoryInfo, EFServiceNBCH>(cancellationToken));
}
}
/// <summary>
/// Добавить в договор поручителей асинхронно.
/// </summary>
/// <param name="clientDB">Список клиентов, в том числе поручителей</param>
/// <param name="account1C">Договор</param>
/// <param name="cancellationToken">Токен отмены</param>
private static async Task AddGuarantorsAsync(ClientDB[] clientDB, Account1C account1C,
CancellationToken cancellationToken)
{
using (IDBSource dbSource = new MKKContext()) {
string[] guarantorsCode = clientDB.
Where(j => j.GuarantorDBs != default).
Select(j => j.Code1C).
ToArray();
ClientDB[] guarantors = dbSource.Clients.
Where(i => guarantorsCode.Contains(i.Code1C)).
ToArray();
AttachAndLogError <Account1C, EFService1C>((MKKContext)dbSource, account1C);
foreach (ClientDB guarantor in guarantors)
{
GuarantorDB guarantorDB = new GuarantorDB()
{
Account = account1C, Client = guarantor
};
await dbSource.GuarantorDBs.AddAsync(guarantorDB, cancellationToken);
}
await dbSource.SaveChangesAndLogErrorAsync <EFService1C>(new LogShortMessage(
message : "/*Метод {methodName}, clientDB {clientDB}, account1C {account1C}*/",
"AddGuarantorsAsync", clientDB, account1C),
cancellationToken
);
}
}
/// <summary>
/// Загрузить ПДН по договору асинхронно.
/// </summary>
/// <param name="document1C">Договор</param>
/// <param name="pdnValue">Значение процента ПДН</param>
/// <param name="cancellationToken">Токен отмены</param>
public async Task LoadPDNFromFileAsync(CreditDocumentNResult document1C, double pdnValue,
CancellationToken cancellationToken)
{
LoadPDNFromFileAsyncCheckParams(document1C);
await UpdateAccountAndClientInfoAsync(document1C, cancellationToken);
string account1CCode = document1C.CreditDocument.Code1C;
using (IDBSource dbSource = new MKKContext()) {
PDNResultDB pdn = await dbSource.PDNResultDBs.
AsNoTracking().
Where(i => i.Account1C.Account1CCode.Equals(account1CCode)).
SingleOrDefaultAndErrorAsync <PDNResultDB, EFService1C>(cancellationToken);
if (pdn == default)
{
pdn = new PDNResultDB();
dbSource.Entry(pdn).State = EntityState.Added;
}
Account1C account1CInDB = await FindAccountAndLogErrorAsync <EFService1C>(account1CCode, cancellationToken);
pdn.Account1C = account1CInDB;
pdn.Percent = pdnValue;
dbSource.Entry(account1CInDB).State = EntityState.Unchanged;
await dbSource.SaveChangesAndLogErrorAsync <EFService1C>(new LogShortMessage(
message : "/*Метод {methodName}, document1C {document1C}, pdnValue {pdnValue}*/",
"AddNewAccountRecordAsync", document1C, pdnValue),
cancellationToken
);
}
}
/// <summary>
/// Добавить новую запись в БД асинхронно.
/// </summary>
/// <param name="account1CDB">Новая запись</param>
/// <param name="cancellationToken">Токен отмены</param>
private async Task AddNewAccountRecordAsync(Account1C account1CDB, CancellationToken cancellationToken)
{
using (MKKContext dbSource = new MKKContext()) {
ClientDB accountClientDB = await FindClientAndLogErrorAsync <EFService1C>(account1CDB.Client.Code1C, cancellationToken);
OrganizationDB organizationDB = await FindRequiredDBRecordByNameAndLogErrorAsync <OrganizationDB, EFService1C>(account1CDB.Organization.Name, cancellationToken);
SellPontDB sellPointDB = await FindRequiredDBRecordByNameAndLogErrorAsync <SellPontDB, EFService1C>(account1CDB.SellPont.Name, account1CDB.SellPont.Code1C, cancellationToken);
TypeOfChargeDB typeOfCharge = await FindRequiredDBRecordByNameAndLogErrorAsync <TypeOfChargeDB, EFService1C>(account1CDB.TypeOfCharge.Name, cancellationToken);
AttachAndLogError <OrganizationDB, EFService1C>(dbSource, organizationDB);
AttachAndLogError <SellPontDB, EFService1C>(dbSource, sellPointDB);
AttachAndLogError <ClientDB, EFService1C>(dbSource, accountClientDB);
AttachAndLogError <TypeOfChargeDB, EFService1C>(dbSource, typeOfCharge);
account1CDB.Organization = organizationDB;
account1CDB.SellPont = sellPointDB;
account1CDB.Client = accountClientDB;
account1CDB.TypeOfCharge = typeOfCharge;
await dbSource.Account1Cs.AddAsync(account1CDB, cancellationToken);
await dbSource.SaveChangesAndLogErrorAsync <EFService1C>(new LogShortMessage(
message : "/*Метод {methodName}, account1C {account1C}*/",
"AddNewAccountRecordAsync", account1CDB),
cancellationToken
);
}
}
/// <summary>
/// Получить данные из кэша.
/// </summary>
/// <param name="login">Поиск по логину</param>
/// <returns>Данные из кэша</returns>
internal new ADLoginsDB this[string login] {
get{
if (login.IndexOf('\\') == -1)
{
throw new ArgumentException($"Неверный формат логина AD. Логин должен быть вида: \"domain\\login\". Передан логин \"{login}\"");
}
login = login.Substring(login.IndexOf('\\') + 1);
lock (Locker) {
if (_ADLogins.Keys.Contains(login))
{
UpdateDataInDB(login);
}
else
{
using (IDBSource dbSource = new MKKContext()) {
ADLoginsDB adLoginsIDB = dbSource.ADLoginsDBs.AsNoTracking().FirstOrDefault(i => i.Login.Equals(login));
if (adLoginsIDB == default)
{
AddDataToDB(dbSource, login);
}
else
{
UpdateCacheFromDB(dbSource, adLoginsIDB, login);
}
}
}
return((ADLoginsDB)_ADLogins[login]);
}
}
}
/// <summary>
/// Получить список проверяющих сотрудников по списку договоров асинхронно.
/// </summary>
/// <param name="accounts"></param>
/// <param name="cancellationToken">Токен отмены</param>
/// <returns>Последняя запись - номер договора/сотрудник</returns>
public async Task <InspectorAccount[]> GedInspectorsByAccountListAsync(string[] accounts,
CancellationToken cancellationToken)
{
GedInspectorsByAccountListCheck(accounts);
using (IDBSource dbSource = new MKKContext()) {
List <AccountInspectingDB> accountInspectors =
await dbSource.
AccountInspectingDB.
AsNoTracking().
Include(i => i.Account1C).
Include(i => i.ADLoginsDB).
Where(i => accounts.Contains(i.Account1CID)).
ToListAndLogErrorAsync <AccountInspectingDB, EFServiceInspecting>(cancellationToken);
InspectorAccount[] result = accountInspectors.
OrderByDescending(o => o.OperationDate).
GroupBy(g => g.Account1C).
Select(i => new InspectorAccount()
{
Account1CCode = i.Key.Account1CCode,
Inspector = i.Select(g => g).FirstOrDefault()?.ADLoginsDB.Name
}).
ToArray();
return(result);
}
}
/// <summary>
/// Получить сохраненный ПДН по номеру договору 1С асинхронно.
/// </summary>
/// <param name="account1CCode">Номер договора из 1С</param>
/// <param name="cancellationToken">Токен отмены</param>
/// <returns>ПДН и дата анкеты, на основании которой был рассчитан ПДН</returns>
public async Task <PDNInfoList> GetSavedPDNAsync(string account1CCode, CancellationToken cancellationToken)
{
GetSavedPDNCheckParams(account1CCode);
using (IDBSource dbSource = new MKKContext()) {
Account1C account1C = await FindAccountAsync(account1CCode, cancellationToken, i => i.PDNData);
if ((account1C?.PDNCreditHistoryAnket ?? default) != default)
{
PDNData[] pdnData = await dbSource.PDNDatas.
Include(i => i.Account1C).
Where(i => i.Account1C.Account1CCode.Equals(account1CCode)).
ToArrayAndLogErrorAsync <PDNData, EFServicePDN>(cancellationToken);
CreditHistory creditHistory = await dbSource.CreditHistories.Where(i => i.ID == account1C.PDNCreditHistoryAnket).
FirstOrDefaultAndLogErrorAsync <CreditHistory, EFServicePDN>(cancellationToken);
return(new PDNInfoList {
PDNCards = pdnData.Where(i => i.PDNCalculateType == PDNCalculateType.Card)
.Select(i => (PDNCard)i).ToArray(),
PDNNonCards = pdnData.Where(i => i.PDNCalculateType == PDNCalculateType.NonCard).Select(i => {
PDNNonCard result = i;
return result;
}).ToArray(),
CreditHistoryID = creditHistory.ID,
ReportDate = creditHistory.Date,
Account1CID = account1CCode
});
}
}
return(default);
/// <summary>
/// Получить кредитную историю по коду клиента 1С асинхронно.
/// Берутся анкеты полученные в день заведения договора, или ранее полученные по этому клиенту.
/// </summary>
/// <param name="client1CCode">Код клиента 1С</param>
/// <param name="accountDate">Дата расчета</param>
/// <param name="cancellationToken">Токен отмены</param>
/// <returns>Кредитная история</returns>
internal static async Task <CreditHistory> GetCreditHistoryByAccount1CCodeAsync <TLoggerClass>(string client1CCode,
DateTime accountDate, CancellationToken cancellationToken) where TLoggerClass : class
{
GetCreditHistoryByAccount1CCodeCheckParams <TLoggerClass>(client1CCode, accountDate);
using (IDBSource dbSource = new MKKContext()) {
CreditHistory[] creditHistorys = await
(from acc in dbSource.Account1Cs.AsNoTracking()
join ch in dbSource.CreditHistories on acc.Account1CCode equals ch.Account1CID.Account1CCode
join cl in dbSource.Clients on ch.Client.ID equals cl.ID
orderby ch.Date descending
where string.Equals(cl.Code1C, client1CCode) && (string.IsNullOrEmpty(ch.ErrorCode) || ch.ErrorCode == SOAPNBCH.ClientNotFoundNBCH)
select ch).
ToArrayAndLogErrorAsync <CreditHistory, EFServicePDN>(cancellationToken);
foreach (var creditHistory in creditHistorys)
{
if (accountDate.AddDays(PDN.MaxDayAfter) >= creditHistory.Date)
{
return(creditHistory);
}
}
}
return(default);
/// <summary>
/// Получить список ПДН асинхронно.
/// </summary>
/// <param name="accounts">Договора для которых необходимо получить ПДН</param>
/// <param name="cancellationToken">Токен отмены</param>
/// <returns>Записи ПДН</returns>
private static async Task <PDNResultDB[]> GetPdnsAsync(IEnumerable <string> accounts, CancellationToken cancellationToken)
{
using (IDBSource dbSource = new MKKContext()) {
return(await dbSource.PDNResultDBs.
AsNoTracking().
Include(i => i.Account1C).
Where(i => accounts.Contains(i.Account1C.Account1CCode)).
Select(i => i).
ToArrayAndLogErrorAsync <PDNResultDB, EFServicePDN>(cancellationToken));
}
}
/// <summary>
/// Вернуть все записи в которых ПДН больше 50% асинхронно.
/// </summary>
/// <param name="cancellationToken">Токен отмены</param>
public async Task <string[]> GetFullRecordOver50PAsync(CancellationToken cancellationToken)
{
using (IDBSource dbSource = new MKKContext()) {
return(await dbSource.PDNResultDBs.
AsNoTracking().
Include(i => i.Account1C).
Where(i => i.Percent >= 50).
Select(i => i.Account1C.Account1CCode).
ToArrayAndLogErrorAsync <string, EFServicePDN>(cancellationToken));
}
}
/// <summary>
/// Вернуть номер последней, сохраненной анкеты асинхронно.
/// </summary>
/// <param name="client1CCode">Код клиента 1С</param>
/// <param name="cancellationToken">Токен отмены</param>
/// <returns>Номер последней анкеты</returns>
public async Task <int> GetClientCreditHistoryIDAsync(string client1CCode, CancellationToken cancellationToken)
{
GetClientCreditHistoryIDCheckParams(client1CCode);
using (IDBSource dbSource = new MKKContext()) {
return(await(from cl in dbSource.Clients.AsNoTracking()
join ch in dbSource.CreditHistories on cl.ID equals ch.Client.ID
where cl.Code1C.Equals(client1CCode)
select ch.ID).
MaxAsync(cancellationToken));
}
}
/// <summary>
/// Обновить данные в БД.
/// </summary>
/// <param name="login">логин пользователя</param>
private void UpdateDataInDB(string login)
{
if (_ADLogins[login].UpdateDate.AddDays(UpdateIntervalInDay) < DateTime.Now)
{
using (IDBSource dBSource = new MKKContext()) {
_ADLogins[login].Name = GetNameByLogin(login);
_ADLogins[login].UpdateDate = DateTime.Now;
dBSource.SaveChanges();
}
}
}
/// <summary>
/// Обновить информацию по договору асинхронно.
/// </summary>
/// <param name="account1CDB">новый договор</param>
/// <param name="presentAccount1C">Договор в базе</param>
/// <param name="cancellationToken">Токен отмены</param>
/// <returns></returns>
private static async Task UpdateAccountRecordAsync(Account1C account1CDB, Account1C presentAccount1C,
CancellationToken cancellationToken)
{
using (IDBSource dbSource = new MKKContext()) {
if (!presentAccount1C.Equals1CParams(account1CDB))
{
AttachAndLogError <Account1C, EFService1C>((MKKContext)dbSource, presentAccount1C);
if (presentAccount1C.Client != default)
{
dbSource.Entry(presentAccount1C.Client).State = EntityState.Detached;
}
presentAccount1C.DateTime = account1CDB.DateTime;
ClientDB clientDB =
await FindClientAndLogErrorAsync <EFService1C>(account1CDB.Client.Code1C, cancellationToken);
dbSource.Entry(clientDB).State = EntityState.Unchanged;
presentAccount1C.Client = clientDB;
dbSource.Entry(presentAccount1C).State = EntityState.Modified;
}
if (presentAccount1C.Organization == default)
{
await UpdateAccountAsync(dbSource, presentAccount1C, account1CDB.Organization, cancellationToken);
}
if (presentAccount1C.SellPont == default)
{
await UpdateAccountAsync(dbSource, presentAccount1C, account1CDB.SellPont, cancellationToken);
}
if (presentAccount1C.TypeOfCharge == default && presentAccount1C.TypeOfCharge?.Name != account1CDB.TypeOfCharge.Name)
{
await UpdateAccountAsync(dbSource, presentAccount1C, account1CDB.TypeOfCharge, cancellationToken);
}
if (presentAccount1C.AdditionAgrement != account1CDB.AdditionAgrement)
{
presentAccount1C.AdditionAgrement = account1CDB.AdditionAgrement;
dbSource.Entry(presentAccount1C).State = EntityState.Modified;
}
await dbSource.SaveChangesAndLogErrorAsync <EFService1C>(new LogShortMessage(
message : "/*Метод {methodName}, document1C {document1C}, pdnValue {pdnValue}*/",
"AddNewAccountRecordAsync", account1CDB, presentAccount1C, cancellationToken),
cancellationToken
);
}
}
/// <summary>
/// Получить список сообщений по выбранному договору асинхронно.
/// </summary>
/// <param name="account">Договор</param>
/// <param name="cancellationToken">Токен отмены</param>
/// <returns>Задача с сообщениями</returns>
private static async Task <List <PostsDB> > GetPostsInAccountAsync(Account1C account,
CancellationToken cancellationToken)
{
using (IDBSource dbSource = new MKKContext()) {
return(await dbSource.PostsDBs.
AsNoTracking().
Include(i => i.Account).
Include(i => i.Author).
Where(i => i.Account.Account1CCode.Equals(account.Account1CCode)).
Select(i => i).
ToListAndLogErrorAsync <PostsDB, EFServicePosts>(cancellationToken));
}
}
/// <summary>
/// функция обновления данных клиента.
/// </summary>
/// <param name="clientTask">Задача с данными клиента</param>
private static void UpdateClientFunction(ClientTask clientTask)
{
using (IDBSource dbSource = new MKKContext()) {
if (clientTask.ClientDB.BirthDate < new DateTime(1920, 1, 1))
{
LogAndThrowException <Exception, EFService1C>(_Logger,
"",
"Проверьте год рождения клиента {clientLastName} {clientFirstName} {clientSecondName}" +
" (код клиента {clientID1C}). Год рождения: {clientBirthDate}./* Метод {methodName}.*/",
clientTask.ClientDB.LastName, clientTask.ClientDB.FirstName,
clientTask.ClientDB.SecondName, clientTask.ClientDB.Code1C, clientTask.ClientDB.BirthDate,
"UpdateClientsInfo");
}
ClientDB presentClient = clientTask.Task.ResultAndThrowException();
ICollection <GuarantorDB> guarantorDB = clientTask.ClientDB.GuarantorDBs;
clientTask.ClientDB.GuarantorDBs = default;
if (presentClient == default)
{
dbSource.Clients.Add(clientTask.ClientDB);
presentClient = clientTask.ClientDB;
}
else
{
dbSource.Entry(presentClient).State = EntityState.Modified;
}
presentClient.BirthDate = clientTask.ClientDB.BirthDate;
presentClient.FIO = clientTask.ClientDB.FIO;
presentClient.FirstName = clientTask.ClientDB.FirstName;
presentClient.LastName = clientTask.ClientDB.LastName;
presentClient.SecondName = clientTask.ClientDB.SecondName;
try { dbSource.SaveChanges(); }
catch (Exception exception) {
LogAndThrowException <Exception, EFService1C>(_Logger,
"",
"Не удалось обновить данные клиента по договору. Клиент {ClientDB}. Ошибка работы" +
" с БД./* Метод {methodName}, исключение: {ContextException}*/",
new ExLogValue()
{
LogValue = clientTask.ClientDB,
ExValue = clientTask.ClientDB.Code1C
},
"UpdateClientsInfo", exception);
}
clientTask.ClientDB.GuarantorDBs = guarantorDB;
}
}
/// <summary>
/// Удалить из договора всех поручителей асинхронно.
/// </summary>
/// <param name="account1C">Договор</param>
/// <param name="cancellationToken">Токен отмены</param>
private static async Task DeleteGuarantorsAsync(Account1C account1C, CancellationToken cancellationToken)
{
using (IDBSource dbSource = new MKKContext()) {
IQueryable <GuarantorDB> guarantorDBs =
dbSource.GuarantorDBs.Where(gr => gr.Account1CID.Equals(account1C.Account1CCode));
dbSource.GuarantorDBs.RemoveRange(guarantorDBs);
await dbSource.SaveChangesAndLogErrorAsync <EFService1C>(new LogShortMessage(
message : "/*Метод {methodName}, guarantorDBs {guarantorDBs}, account1C {account1C}*/",
"DeleteGuarantorsAsync", guarantorDBs, account1C),
cancellationToken
);
}
}
/// <summary>
/// Поиск клиента в базе.
/// </summary>
/// <param name="fio">часть имени клиента</param>
/// <param name="cancellationToken">Токен отмены</param>
/// <returns>Совпадения</returns>
public async Task <SearchClientList[]> SearchClientAsync(string fio, CancellationToken cancellationToken)
{
SearchClientAsyncCheckParams(fio);
using (IDBSource dbSource = new MKKContext()) {
return(await dbSource.Clients.
AsNoTracking().
Where(i => i.FIO.Contains(fio)).
Select(i => new SearchClientList()
{
BirthDate = i.BirthDate,
FIO = i.FIO,
ClientID = i.ID,
ClientID1C = i.Code1C
}
).ToArrayAndLogErrorAsync <SearchClientList, EFServiceNBCH>(cancellationToken));
}
}
/// <summary>
/// Получить список сохраненных КИ по коду клиента 1С асинхронно.
/// </summary>
/// <param name="client1CCode">Код клиента 1С</param>
/// <param name="cancellationToken">Токен отмены</param>
/// <returns>Список сохраненных КИ</returns>
public async Task <CreditHistoryInfo[]> GetCreditHistoryListAsync(string client1CCode, CancellationToken cancellationToken)
{
GetCreditHistoryListCheckParams(client1CCode);
using (IDBSource dbSource = new MKKContext()) {
return(await dbSource.CreditHistories.
AsNoTracking().
Where(i => i.Client.Code1C.Equals(client1CCode)).
Select(i => new CreditHistoryInfo()
{
CreditHistoryID = i.ID,
Date = i.Date,
ErrorText = i.ErrorText,
ErrorCode = i.ErrorCode
}).
OrderByDescending(o => o.Date).
ToArrayAndLogErrorAsync <CreditHistoryInfo, EFServiceNBCH>(cancellationToken));
}
}
/// <summary>
/// Добавить сообщение асинхронно.
/// </summary>
/// <param name="adLogin">AD логин пользователя</param>
/// <param name="account1CCode">Код договора 1С</param>
/// <param name="post">Сообщение для добавления</param>
/// <param name="clientTimeZone">Часовой пояс клиента</param>
/// <param name="cancellationToken">Токен отмены</param>
/// <returns></returns>
public async Task AddPostAsync(string adLogin, string account1CCode, Post post, int clientTimeZone,
CancellationToken cancellationToken)
{
AddPostCheckParams(adLogin, account1CCode, post, clientTimeZone);
using (IDBSource dbSource = new MKKContext()) {
PostsDB postDB = await PostsDB.CreatePostsDB(post, clientTimeZone, adLogin, CancellationToken.None);
await dbSource.PostsDBs.AddAsync(postDB, cancellationToken);
AttachAndLogError <Account1C, EFServicePosts>(dbSource, postDB.Account);
AttachAndLogError <ADLoginsDB, EFServicePosts>(dbSource, postDB.Author);
await dbSource.SaveChangesAndLogErrorAsync <EFServicePosts>(new LogShortMessage(
message : "/*Метод {methodName}, adLogin {adLogin}, account1CCode {account1CCode}, post {post}*/",
"AddPostAsync", adLogin, account1CCode, post),
cancellationToken
);
}
}
/// <summary>
/// Установить проверяющего асинхронно.
/// </summary>
/// <param name="account1CCode">Номер договора 1С</param>
/// <param name="login">Логин проверяющего</param>
/// <param name="assignDate">Дата операции</param>
/// <param name="timeZone">Часовой пояс проверяющего</param>
/// <param name="cancellationToken">Токен отмены</param>
public async Task SetInspectionAsync(string account1CCode, string login, DateTime assignDate, int timeZone,
CancellationToken cancellationToken)
{
SetInspectionCheckParams(login, assignDate, timeZone);
using (IDBSource dbSource = new MKKContext()) {
Account1C account1C = await FindAccountAndLogErrorAsync <EFServiceInspecting>(account1CCode, cancellationToken);
ADLoginsDB adLogin = Singleton <ProxyADLoginsDB> .Values[login];
await dbSource.AccountInspectingDB.AddAsync(
new AccountInspectingDB()
{
Account1CID = account1C.Account1CCode,
OperationDate = assignDate,
TimeZone = timeZone,
UserPermission = PermissionLevel.GetInt(login),
ADLoginsDBID = adLogin.ID
},
cancellationToken);
await dbSource.SaveChangesAndLogErrorAsync <EFServiceInspecting>(cancellationToken);
}
}