/// <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>
/// Обновить информацию по договору 1С асинхронно.
/// </summary>
/// <param name="document1C">Договора 1С</param>
/// <param name="cancellationToken">Токен отмены</param>
public async Task UpdateAccountAndClientInfoAsync(CreditDocumentNResult document1C,
CancellationToken cancellationToken)
{
UpdateAccountAndClientInfoCheckParams(document1C);
Account1C account1C = (Account1C)document1C.CreditDocument;
ClientDB[] clientDBs = ClientsFromAccount(document1C, account1C);
ClientTask[] presentClientsTask = clientDBs.AsParallel().
Select(i => new ClientTask()
{
ClientDB = i,
Task = FindClientAndLogErrorAsync <EFService1C>(i.Code1C, cancellationToken)
}).
WithCancellation(cancellationToken).
ToArray();
UpdateClientsInfo(presentClientsTask, cancellationToken);
Account1C presentAccount1CTask = await FindAccountAndLogErrorAsync <EFService1C>(
account1C.Account1CCode,
cancellationToken,
c => c.Client, o => o.Organization, sp => sp.SellPont, cht => cht.TypeOfCharge);
await UpdateAccount1CInfoAsync(account1C, presentAccount1CTask, cancellationToken);
if (clientDBs.Length > 1)
{
await UpdateGuarantorsAsync(clientDBs, cancellationToken);
}
}
/// <summary>
/// Получить список клиентов из договора.
/// </summary>
/// <param name="document">Договор 1С из вебсервиса</param>
/// <param name="account1C">Договор 1С</param>
/// <returns>Список клиентов</returns>
private static ClientDB[] ClientsFromAccount(CreditDocumentNResult document, Account1C account1C)
{
List <ClientDB> clientDBs = new List <ClientDB> {
(ClientDB)document.CreditDocument.Client
};
foreach (ClientProfile client in document.CreditDocument?.Guarantors ?? new ClientProfile[0])
{
if (SOAP1C.StringToDateTime(client.BirthDate) < new DateTime(1920, 1, 1))
{
LogAndThrowException <Exception, EFService1C>(_Logger,
"",
"Проверьте год рождения клиента {clientLastName} {clientFirstName} {clientSecondName}" +
" (код клиента {clientID1C}). Год рождения:{clientBirthDate)}./* Метод {methodName}.*/",
client.LastName, client.FirstName, client.SecondName, client.ID1C, client.BirthDate,
"CreditDocumentNResult");
}
ClientDB clientDB = (ClientDB)client;
List <GuarantorDB> guarantors = new List <GuarantorDB> {
new GuarantorDB()
{
Account = account1C
}
};
clientDB.GuarantorDBs = guarantors;
clientDBs.Add(clientDB);
}
return(clientDBs.ToArray());
}
/// <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>
/// Добавить новую запись в БД асинхронно.
/// </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="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="clientDB">Клиент</param>
/// <param name="cancellationToken">Токен отмены</param>
private static async Task UpdateGuarantorsAsync(ClientDB[] clientDB, CancellationToken cancellationToken)
{
string account1CCode = clientDB.Where(acc => acc.GuarantorDBs != default).
Select(acc => acc.GuarantorDBs).FirstOrDefault().FirstOrDefault()?.Account.Account1CCode;
Account1C account1C = await FindAccountAndLogErrorAsync <EFService1C>(account1CCode, cancellationToken);
await DeleteGuarantorsAsync(account1C, cancellationToken);
await AddGuarantorsAsync(clientDB, account1C, cancellationToken);
}
/// <summary>
/// Обновить/добавить по договору 1С запись в БД асинхронно.
/// </summary>
/// <param name="account1CDB">Договор из 1С</param>
/// <param name="presentAccount1C">Договор из 1С в БД</param>
/// <param name="cancellationToken">Токен отмены</param>
private async Task UpdateAccount1CInfoAsync(Account1C account1CDB, Account1C presentAccount1C,
CancellationToken cancellationToken)
{
if (presentAccount1C == default)
{
await AddNewAccountRecordAsync(account1CDB, cancellationToken);
}
else
{
await UpdateAccountRecordAsync(account1CDB, presentAccount1C, cancellationToken);
}
}
/// <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>
/// <typeparam name="TEntity">Обновляемый тип данных</typeparam>
/// <param name="dbSource">Источник данных</param>
/// <param name="account1C">Счет</param>
/// <param name="value">Новое значение</param>
/// <param name="cancellationToken">Токен отмены</param>
private static async Task UpdateAccountAsync <TEntity>(IDBSource dbSource, Account1C account1C, TEntity value,
CancellationToken cancellationToken) where TEntity : class, IDBTableName, new()
{
AttachAndLogError <Account1C, EFService1C>((MKKContext)dbSource, account1C);
TEntity valueDB =
await FindRequiredDBRecordByNameAndLogErrorAsync <TEntity, EFService1C>(value.Name, cancellationToken);
string fieldName = valueDB.GetType().Name.Substring(0, (valueDB.GetType().Name.Length - "DB".Length));
dbSource.Entry(valueDB).State = EntityState.Unchanged;
account1C.GetType().GetProperty(fieldName)?.SetValue(account1C, valueDB);
dbSource.Entry(account1C).State = EntityState.Modified;
}
/// <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="account">Договор, до которого необходимо получить все сообщения</param>
/// <param name="cancellationToken">Токен отмены</param>
/// <returns>Задача с сообщениями</returns>
private static async Task <List <PostsDB> > GetPostsByClientAsync(Account1C account,
CancellationToken cancellationToken)
{
using (IDBSource dbSource = new NBCH_EF.MKKContext()) {
return(await dbSource.PostsDBs.
AsNoTracking().
Include(i => i.Account).
Include(i => i.Account.Client).
Include(i => i.Author).
Where(
i => i.Account.Client.ID.Equals(account.Client.ID) &&
i.Account.DateTime <= account.DateTime &&
!i.Account.Account1CCode.Equals(account.Account1CCode)
).ToListAndLogErrorAsync <PostsDB, EFServicePosts>(cancellationToken));
}
}
/// <summary>
/// Проверить доступ к договору по организации и логину пользователя.
/// </summary>
/// <param name="adLogin">Логин пользователя</param>
/// <param name="account1CCode">Номер договора 1С</param>
/// <param name="cancellationToken">Токен отмены</param>
/// <returns></returns>
internal static async Task <bool> HaveAccessToAccountAsync(string adLogin, string account1CCode,
CancellationToken cancellationToken)
{
Account1C account = await FindAccountAsync(account1CCode, cancellationToken, i => i.Organization);
Organizations[] orgs = OrganizationsByLogin(adLogin);
foreach (Organizations organizations in orgs)
{
if (account.Organization.Name.Equals(organizations.GetDescription()))
{
return(true);
}
}
return(false);
}
/// <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);
}
}
/// <summary>
/// Получить все сообщения по договору асинхронно.
/// </summary>
/// <param name="adLogin">Логин пользователя AD</param>
/// <param name="account1CCode">Номер договора 1С</param>
/// <param name="cancellationToken">Токен отмены</param>
/// <returns>Все сообщения по договору</returns>
public async Task <Post[]> GetPostsAsync(string adLogin, string account1CCode, CancellationToken cancellationToken)
{
GetPostsCheckParams(adLogin, account1CCode);
ADLoginsDB author = Singleton <ProxyADLoginsDB> .Values[adLogin];
Account1C account = await FindAccountAndLogErrorAsync <EFServicePosts>(account1CCode, cancellationToken,
i => i.Client);
if (account == default)
{
return(new Post[0]);
}
Task <List <PostsDB> > postsInAccountTask = GetPostsInAccountAsync(account, cancellationToken);
Task <List <PostsDB> > postsByClientTask = GetPostsByClientAsync(account, cancellationToken);
List <PostsDB> posts = (await postsByClientTask).Where(i => i.Author.ID.Equals(author.ID) || CanReadAllPost(adLogin)).ToList();
posts.AddRange((await postsInAccountTask).Where(i => i.Author.ID.Equals(author.ID) || CanReadAllPost(adLogin)).ToArray());
Post[] result = posts.Select(i => (Post)i).ToArray();
return(result);
}
