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>()); }