public Task <IEnumerable <CreditRequestDto> > HandleAsync(DepartmentRequestsQuery query)
{
return(ModelsDao.Where(
m => (m.IsOperatorApproved ?? false) && (m.IsSecurityApproved ?? false) &&
(m.IsCreditCommitteeApproved ?? false) && m.IsCreditDepartmentApproved == null)
.MapToAsync <CreditRequestDto>());
}
public void Append2Database(List <Editorial> editorials)
{
List <string> col = new List <string>();
ModelsDao modelsDAO = new ModelsDao();
foreach (Editorial e in editorials)
{
Console.WriteLine(e.Name);
modelsDAO.AddEditorial(e);
foreach (Collection c in e.Collections)
{
Console.WriteLine("\t" + c.Name);
modelsDAO.AddCollection(c, e.Id);
if (!c.Comics.Any())
{
col.Add(e.Id + " - " + c.Id + " - " + c.Name);
}
foreach (Comic co in c.Comics)
{
Console.WriteLine("\t\t" + co.Name);
modelsDAO.AddComic(co, c.Id);
}
}
}
foreach (string s in col)
{
Console.WriteLine(s);
}
}
public async Task <IEnumerable <CreditAccountStateDto> > HandleAsync(CreditAccountStatesQuery query)
{
var creditAccount = await ModelsDao.FindAsync(query.CreditAccountId);
return(creditAccount?.CreditAccountStates.MapTo <CreditAccountStateDto>() ??
Enumerable.Empty <CreditAccountStateDto>());
}
public IEnumerable <CreditAccountStateDto> Handle(CreditAccountStatesQuery query)
{
var creditAccount = ModelsDao.Find(query.CreditAccountId);
return(creditAccount?.CreditAccountStates.MapTo <CreditAccountStateDto>() ??
Enumerable.Empty <CreditAccountStateDto>());
}
public IEnumerable <CreditRequestDto> Handle(ApprovedClientRequestsQuery query)
{
return(ModelsDao.Where(
m => (m.IsOperatorApproved ?? false) && (m.IsSecurityApproved ?? false) &&
(m.IsCreditCommitteeApproved ?? false) && (m.IsCreditDepartmentApproved ?? false) &&
m.Client.Id == query.ClientId && !(m.IsOpen ?? false))
.MapTo <CreditRequestDto>());
}
public void Execute(CreateModelCommand <TModelDto> command)
{
var model = CreateDbModel(command.ModelDto);
RestoreFkModels(model, command.ModelDto);
ModelsDao.Add(model);
Save();
Mapper.Map(model, command.ModelDto);
}
public async Task ExecuteAsync(CreateModelCommand <TModelDto> command)
{
var model = CreateDbModel(command.ModelDto);
RestoreFkModels(model, command.ModelDto);
ModelsDao.Add(model);
await SaveAsync();
Mapper.Map(model, command.ModelDto);
}
public void Execute(DeleteModelCommand command)
{
var model = ModelsDao.Find(command.Id);
if (model == null)
{
throw new ArgumentException($"{typeof(TModel).Name} with given Id not found");
}
ModelsDao.Remove(model);
Save();
}
public async Task ExecuteAsync(DeleteModelCommand command)
{
var model = await ModelsDao.FindAsync(command.Id);
if (model == null)
{
throw new ArgumentException($"{typeof(TModel).Name} with given Id not found");
}
ModelsDao.Remove(model);
await SaveAsync();
}
public async Task <IEnumerable <CreditAccountDto> > HandleAsync(CreditAccountsQuery query)
{
if (query.ClientId.HasValue)
{
return(await ModelsDao.Where(a => a.Client.Id == query.ClientId).MapToAsync <CreditAccountDto>());
}
if (!string.IsNullOrWhiteSpace(query.PassportNumber))
{
return(await ModelsDao.Where(a => a.Client.PassportNumber == query.PassportNumber).MapToAsync <CreditAccountDto>());
}
return(Enumerable.Empty <CreditAccountDto>());
}
private List <Collection> GetCollections(string editorialId, FileInfo file, ModelsDao modelsDao)
{
string line;
List <Collection> collections = new List <Collection>();
using StreamReader streamReader = new StreamReader(file.FullName);
while ((line = streamReader.ReadLine()) != null)
{
collections.Add(new Collection(line));
}
return(collections);
}
public EmployeeDto Handle(EmployeeQuery query)
{
EmployeeModel model = null;
if (query.Id.HasValue)
{
model = ModelsDao.Find(query.Id.Value);
}
if (query.UserId.HasValue)
{
model = ModelsDao.FirstOrDefault(e => e.User.Id == query.UserId);
}
return(model == null ? null : Mapper.Map <EmployeeDto>(model));
}
public CreditAccountDto Handle(CreditAccountQuery query)
{
CreditAccountModel model = null;
if (query.Id.HasValue)
{
model = ModelsDao.Find(query.Id.Value);
}
if (!string.IsNullOrEmpty(query.AgreementNumber))
{
model = ModelsDao.FirstOrDefault(u => u.CreditAgreementNumber == query.AgreementNumber);
}
return(model == null ? null : Mapper.Map <CreditAccountDto>(model));
}
public async Task <EmployeeDto> HandleAsync(EmployeeQuery query)
{
EmployeeModel model = null;
if (query.Id.HasValue)
{
model = await ModelsDao.FindAsync(query.Id.Value);
}
if (query.UserId.HasValue)
{
model = await ModelsDao.FirstOrDefaultAsync(e => e.User.Id == query.UserId);
}
return(model == null ? null : Mapper.Map <EmployeeDto>(model));
}
public void CheckHealth()
{
ModelsDao modelsDAO = new ModelsDao();
List <Comic> comics = modelsDAO.GetComics();
if (comics.Any())
{
foreach (Comic c in comics)
{
Console.WriteLine(c.Link);
c.Status = CheckLink(c);
modelsDAO.UpdateComic(c);
}
}
}
public void Execute(UpdateModelsCommand <TModelDto> command)
{
foreach (var modelDto in command.ModelsDto)
{
var model = ModelsDao.Find(modelDto.Id);
if (model == null)
{
throw new ArgumentException($"{typeof(TModel).Name} with given Id not found");
}
UpdateDbModel(model, modelDto);
RestoreFkModels(model, modelDto);
Context.Entry(model).State = EntityState.Modified;
}
Save();
}
public async Task ExecuteAsync(UpdateModelCommand <TModelDto> command)
{
var model = await ModelsDao.FindAsync(command.ModelDto.Id);
if (model == null)
{
throw new ArgumentException($"{typeof(TModel).Name} with given Id not found");
}
UpdateDbModel(model, command.ModelDto);
RestoreFkModels(model, command.ModelDto);
Context.Entry(model).State = EntityState.Modified;
await SaveAsync();
Mapper.Map(model, command.ModelDto);
}
public void ReadCollections(List <Collection> collections)
{
ModelsDao modelsDAO = new ModelsDao();
FileInfo[] files = new DirectoryInfo(Config.CollectionsPaths).GetFiles();
foreach (FileInfo fileCollection in files)
{
Collection c = collections.FirstOrDefault(x => x.Name == fileCollection.Name.Replace(".txt", string.Empty));
if (c != null)
{
GetComics(c, fileCollection, modelsDAO);
}
}
}
public List <Editorial> ReadEditorials()
{
List <Editorial> editorials = new List <Editorial>();
ModelsDao modelsDAO = new ModelsDao();
FileInfo[] files = new DirectoryInfo(Config.EditorialPaths).GetFiles();
foreach (FileInfo fileEditorial in files)
{
Editorial e = new Editorial(fileEditorial.Name.Replace(".txt", string.Empty));
e.Collections = GetCollections(e.Id, fileEditorial, modelsDAO);
editorials.Add(e);
}
return(editorials);
}
public void Execute(UpdateModelCommand <TModelDto> command)
{
// if we requested a model with certain then
// context already has an attached model with this id
// therefore we have to find it or we will get key conflict
var model = ModelsDao.Find(command.ModelDto.Id);
if (model == null)
{
throw new ArgumentException($"{typeof(TModel).Name} with given Id not found");
}
UpdateDbModel(model, command.ModelDto);
RestoreFkModels(model, command.ModelDto);
Context.Entry(model).State = EntityState.Modified;
Save();
Mapper.Map(model, command.ModelDto);
}
public async Task <UserDto> HandleAsync(UserQuery query)
{
UserModel model = null;
if (query.Id.HasValue)
{
model = await ModelsDao.FindAsync(query.Id.Value);
}
if (!string.IsNullOrEmpty(query.Email))
{
model = await ModelsDao.FirstOrDefaultAsync(u => u.Email == query.Email);
}
if (!string.IsNullOrEmpty(query.Username))
{
model = await ModelsDao.FirstOrDefaultAsync(u => u.Username == query.Username);
}
return(model == null ? null : Mapper.Map <UserDto>(model));
}
public async Task <ClientDto> HandleAsync(ClientQuery query)
{
ClientModel model = null;
if (query.Id.HasValue)
{
model = await ModelsDao.FindAsync(query.Id.Value);
}
if (query.UserId.HasValue)
{
model = await ModelsDao.FirstOrDefaultAsync(c => c.User.Id == query.UserId);
}
if (!string.IsNullOrEmpty(query.PassportNumber))
{
model = await ModelsDao.FirstOrDefaultAsync(c => c.PassportNumber == query.PassportNumber);
}
return(model == null ? null : Mapper.Map <ClientDto>(model));
}
public UserDto Handle(UserQuery query)
{
UserModel model = null;
if (query.Id.HasValue)
{
model = ModelsDao.Find(query.Id.Value);
}
if (!string.IsNullOrEmpty(query.Email))
{
model = ModelsDao.FirstOrDefault(u => u.Email == query.Email);
}
if (!string.IsNullOrEmpty(query.Username))
{
model = ModelsDao.FirstOrDefault(u => u.Username == query.Username);
}
return(model == null ? null : Mapper.Map <UserDto>(model));
}
private void GetComics(Collection collection, FileInfo file, ModelsDao modelsDao)
{
StringBuilder stringBuilder = new StringBuilder();
string line;
using StreamReader streamReader = new StreamReader(file.FullName);
while ((line = streamReader.ReadLine()) != null)
{
stringBuilder.Append(line);
}
try
{
foreach (JToken x1 in (JArray)JsonConvert.DeserializeObject(stringBuilder.ToString()))
{
Comic c = JsonConvert.DeserializeObject <Comic>(x1.ToString());
collection.Comics.Add(c);
}
}
catch { }
}
public async Task <CreditAccountStateDto> HandleAsync(ActualCreditAccountStateQuery query)
{
CreditAccountModel creditAccount = null;
if (query.Id.HasValue)
{
creditAccount = await ModelsDao.FindAsync(query.Id.Value);
}
if (!string.IsNullOrEmpty(query.AgreementNumber))
{
creditAccount = await ModelsDao.FirstOrDefaultAsync(u => u.CreditAgreementNumber == query.AgreementNumber);
}
if (creditAccount == null)
{
return(null);
}
var creditAccountStatesQuery = new CreditAccountStatesQuery {
CreditAccountId = creditAccount.Id
};
var latestCreditAccountState = await HandleAsync(creditAccountStatesQuery);
return(latestCreditAccountState.OrderBy(s => s.Month).LastOrDefault());
}
public IEnumerable <CreditRequestDto> Handle(CommiteeRequestsQuery query)
{
return(ModelsDao.Where(
m => (m.IsOperatorApproved ?? false) && (m.IsSecurityApproved ?? false) &&
m.IsCreditCommitteeApproved == null).MapTo <CreditRequestDto>());
}
public TModelDto Handle(ModelQuery query)
{
return(Mapper.Map <TModelDto>(ModelsDao.Find(query.Id)));
}
public async Task <TModelDto> HandleAsync(ModelQuery query)
{
return(Mapper.Map <TModelDto>(await ModelsDao.FindAsync(query.Id)));
}
public Task <IEnumerable <CreditRequestDto> > HandleAsync(ClientRequestsQuery query)
{
return(ModelsDao.Where(m => m.Client.Id == query.ClientId && !(m.IsOpen ?? false)).MapToAsync <CreditRequestDto>());
}
public Task <IEnumerable <CreditRequestDto> > HandleAsync(OperatorRequestsQuery query)
{
return(ModelsDao.Where(m => m.IsOperatorApproved == null).MapToAsync <CreditRequestDto>());
}
