public override async Task <ErrorRepsonse <RegionDto> > Update(UpdateRegionDto updateDto)
{
var region = await _repository.GetById(updateDto.Id);
var similar = await _repository.Any(c => c.CountryId == region.CountryId && c.Name == updateDto.Name && c.Id != updateDto.Id);
if (similar)
{
return(new ErrorRepsonse <RegionDto>()
{
Errors = new List <string>()
{
"Region.Exsist"
}
});
}
region.Name = updateDto.Name;
await _repository.Update(region);
var response = new ErrorRepsonse <RegionDto>(_mapper.Map <RegionDto>(region));
if (!response.Errors.Any())
{
RemoveCash();
}
return(response);
}
public override async Task <ErrorRepsonse <GroupDto> > AddAsync(CreateGroupDto createDto)
{
createDto.Name = createDto.Name.Trim();
var similar = await _repository.Any(c => c.Name == createDto.Name);
var response = new ErrorRepsonse <GroupDto>();
if (similar)
{
response.Errors.Add("Similar");
}
else
if (createDto.PrivilegesId?.Any() != true)
{
response.Errors.Add("Privileges is required");
}
else
{
var group = _mapper.Map <Group>(createDto);
await _repository.AddAsync(group);
var dto = _mapper.Map <GroupDto>(group);
response.Data = dto;
}
return(response);
}
public async Task <ErrorRepsonse <PhoneDto> > AddPhone(AddPhoneDto addPhoneDto)
{
var client = await _repository.GetById(addPhoneDto.objectId);
var response = new ErrorRepsonse <PhoneDto>();
if (client == null)
{
response.Errors.Add("Not.Found");
return(response);
}
await _repository.LoadCollection(client, c => c.ClientPhones);
if (client.ClientPhones.Any(c => c.Phone == addPhoneDto.Phone))
{
response.Errors.Add("Dublicate");
return(response);
}
var clientPhone = new ClientPhone()
{
ClientId = client.Id,
Phone = addPhoneDto.Phone
};
client.ClientPhones.Add(clientPhone);
await _repository.Update(client);
response.Data = _mapper.Map <PhoneDto>(clientPhone);
RemoveCash();
return(response);
}
public override async Task <ErrorRepsonse <CountryDto> > AddAsync(CreateCountryDto createDto)
{
var response = new ErrorRepsonse <CountryDto>();
var similer = await _repository.FirstOrDefualt(c => c.Name == createDto.Name);
if (similer != null)
{
response.Errors.Add("Country.Similar");
return(response);
}
var country = _mapper.Map <Country>(createDto);
if (!(await _repository.Any()))
{
country.IsMain = true;
}
await _repository.AddAsync(country);
if (country.MediatorId != null)
{
await _repository.LoadRefernces(country, c => c.Mediator);
}
response = new ErrorRepsonse <CountryDto>(_mapper.Map <CountryDto>(country));
RemoveCash();
return(response);
}
public override async Task <ErrorRepsonse <OutComeTypeDto> > Delete(int id)
{
var enrity = await _repository.GetById(id);
var response = new ErrorRepsonse <OutComeTypeDto>();
if (enrity == null)
{
response.NotFound = true;
response.Errors.Add("Not.Found");
}
else
{
if (await _outcomeRepository.Any(c => c.OutComeTypeId == id))
{
response.CantDelete = true;
response.Errors.Add("Cant.Delete");
}
else
{
await _repository.Delete(enrity);
response.Data = _mapper.Map <OutComeTypeDto>(enrity);
}
}
return(response);
}
public virtual async Task <ErrorRepsonse <TDTO> > Update(UpdateDto updateDto)
{
var entity = _mapper.Map <TEntity>(updateDto);
await _repository.Update(entity);
var response = new ErrorRepsonse <TDTO>(_mapper.Map <TDTO>(entity));
return(response);
}
public virtual async Task <ErrorRepsonse <TDTO> > AddAsync(CreateDto createDto)
{
var entity = _mapper.Map <TEntity>(createDto);
await _repository.AddAsync(entity);
var response = new ErrorRepsonse <TDTO>(_mapper.Map <TDTO>(entity));
return(response);
}
public override async Task <ErrorRepsonse <ClientDto> > Delete(int id)
{
var response = new ErrorRepsonse <ClientDto>();
if (await _orderRepository.Any(c => c.ClientId == id))
{
response.Errors.Add("Cann't delete");
return(response);
}
return(await base.Delete(id));
}
public virtual async Task <ErrorRepsonse <TDTO> > Delete(int id)
{
var response = new ErrorRepsonse <TDTO>();
var entity = await _repository.GetById(id);
if (entity == null)
{
response.Errors.Add("Not.Found");
return(response);
}
await _repository.Delete(entity);
response.Data = _mapper.Map <TDTO>(entity);
return(response);
}
public override async Task <ErrorRepsonse <UserDto> > Update(UpdateUserDto updateDto)
{
var user = await _repository.GetById(updateDto.Id);
await _repository.LoadCollection(user, c => c.AgentCountrs);
bool requeirdReacsh = user.CanWorkAsAgent == true ? true : updateDto.CanWorkAsAgent != user.CanWorkAsAgent;
var similerUserByname = await _repository.Any(c => c.Name.ToLower() == updateDto.Name.ToLower() && c.Id != updateDto.Id);
if (similerUserByname)
{
return(new ErrorRepsonse <UserDto>()
{
Errors = new List <string>()
{
"Employee.Exisit"
}
});
}
updateDto.UserName = updateDto.UserName.Trim();
if (!String.IsNullOrWhiteSpace(updateDto.UserName))
{
var similerUserByUserName = await _repository.Any(c => c.UserName.ToLower() == updateDto.UserName.ToLower() && c.Id != updateDto.Id);
if (similerUserByUserName)
{
return(new ErrorRepsonse <UserDto>()
{
Errors = new List <string>()
{
"Employee.Exisit"
}
});
}
}
user.AgentCountrs.Clear();
_mapper.Map <UpdateUserDto, User>(updateDto, user);
await _repository.Update(user);
if (requeirdReacsh)
{
RemoveCash();
}
var response = new ErrorRepsonse <UserDto>(_mapper.Map <UserDto>(await GetById(user.Id)));
return(response);
}
public override async Task <ErrorRepsonse <CountryDto> > Update(UpdateCountryDto updateDto)
{
var similar = await _repository.Any(c => c.Name == updateDto.Name && c.Id != updateDto.Id);
var response = new ErrorRepsonse <CountryDto>();
if (similar)
{
response.Errors.Add("There.Is.Similar.Country");
return(response);
}
response = await base.Update(updateDto);
return(response);
}
public override async Task <ErrorRepsonse <ClientDto> > AddAsync(CreateClientDto createDto)
{
var response = new ErrorRepsonse <ClientDto>();
if (await _repository.Any(c => c.UserName.ToLower() == createDto.UserName || c.Name.ToLower() == createDto.Name.ToLower()))
{
response.Errors.Add("Exisit");
return(response);
}
var client = _mapper.Map <Client>(createDto);
await _repository.AddAsync(client);
client = await _repository.GetById(client.Id);
RemoveCash();
return(new ErrorRepsonse <ClientDto>(_mapper.Map <ClientDto>(client)));
}
public override async Task <ErrorRepsonse <UserDto> > Delete(int id)
{
var user = await _repository.GetById(id);
if (user == null)
{
return new ErrorRepsonse <UserDto>()
{
Errors = new List <string>()
{
"Not.Found"
}
}
}
;
var canntDelete = new ErrorRepsonse <UserDto>(_mapper.Map <UserDto>(user));
canntDelete.Errors.Add("Cannt.Delete");
await _repository.LoadCollection(user, c => c.Incomes);
if (user.Incomes.Any())
{
return(canntDelete);
}
await _repository.LoadCollection(user, c => c.OutComes);
if (user.OutComes.Any())
{
return(canntDelete);
}
await _repository.LoadCollection(user, c => c.Clients);
if (user.Clients.Any())
{
return(canntDelete);
}
if (await _orderRepository.Any(c => c.AgentId == user.Id))
{
return(canntDelete);
}
return(await base.Delete(id));
}
public override async Task <ErrorRepsonse <CountryDto> > Delete(int id)
{
var country = await _repository.GetById(id);
await _repository.LoadCollection(country, c => c.Clients);
await _repository.LoadCollection(country, c => c.AgentCountrs);
var response = new ErrorRepsonse <CountryDto>();
if (country.AgentCountrs.Any() || country.Clients.Any())
{
response.Errors.Add("Cant.Delete");
return(response);
}
response = await base.Delete(id);
return(response);
}
public override async Task <ErrorRepsonse <RegionDto> > AddAsync(CreateRegionDto createDto)
{
var response = new ErrorRepsonse <RegionDto>();
var similar = await _repository.Any(c => c.Name == createDto.Name && c.CountryId == createDto.CountryId);
if (similar)
{
response.Errors.Add("Region.Exisit");
return(response);
}
var entity = _mapper.Map <Region>(createDto);
await _repository.AddAsync(entity);
await _repository.LoadRefernces(entity, c => c.Country);
response = new ErrorRepsonse <RegionDto>(_mapper.Map <RegionDto>(entity));
RemoveCash();
return(response);
}
public override async Task <ErrorRepsonse <TDTO> > AddAsync(CreateDto createDto)
{
var similar = await _repository.Any(c => c.Name == createDto.Name);
var response = new ErrorRepsonse <TDTO>();
if (similar == true)
{
response.Errors.Add("Similar");
}
else
{
var entity = _mapper.Map <TEntity>(createDto);
await _repository.AddAsync(entity);
var dto = _mapper.Map <TDTO>(entity);
response.Data = dto;
}
return(response);
}
public override async Task <ErrorRepsonse <TDTO> > Update(UpdateDto updateDto)
{
var similar = await _repository.Any(c => c.Id != updateDto.Id && c.Name == updateDto.Name);
var response = new ErrorRepsonse <TDTO>();
if (similar == true)
{
response.Errors.Add("Similar");
}
else
{
var entity = await _repository.GetById(updateDto.Id);
_mapper.Map(updateDto, entity);
await _repository.Update(entity);
response.Data = _mapper.Map <TDTO>(entity);
}
return(response);
}
public override async Task <ErrorRepsonse <GroupDto> > Update(UpdateGroupDto updateDto)
{
var similar = await _repository.Any(c => c.Id != updateDto.Id && c.Name == updateDto.Name);
var response = new ErrorRepsonse <GroupDto>();
if (similar)
{
response.Errors.Add("Similar");
}
else
{
var group = await _repository.FirstOrDefualt(c => c.Id == updateDto.Id);
if (group == null)
{
response.NotFound = true;
}
else
{
group.Name = updateDto.Name;
await _repository.LoadCollection(group, c => c.GroupPrivileges);
group.GroupPrivileges = group.GroupPrivileges.Where(c => updateDto.Privileges.Contains(c.PrivilegId)).ToList();
var newPrivlieges = updateDto.Privileges.Except(group.GroupPrivileges.Select(c => c.PrivilegId));
foreach (var item in newPrivlieges)
{
group.GroupPrivileges.Add(new GroupPrivilege()
{
GroupId = group.Id, PrivilegId = item
});
}
await _repository.Update(group);
response.Data = _mapper.Map <GroupDto>(group);
}
}
return(response);
}
public override async Task <ErrorRepsonse <GroupDto> > Delete(int id)
{
var group = (await _repository.GetAsync(c => c.Id == id, c => c.GroupPrivileges)).FirstOrDefault();
var response = new ErrorRepsonse <GroupDto>();
if (group == null)
{
response.NotFound = true;
}
else
{
var count = await _privilegeRepository.Count();
if (group.GroupPrivileges.Count() == count)
{
var groups = await _repository.GetAll(c => c.GroupPrivileges);
if (groups.Any(c => c.GroupPrivileges.Count() != count))
{
response.CantDelete = true;
}
else
{
await _repository.Delete(group);
response.Data = _mapper.Map <GroupDto>(group);
}
}
else
{
await _repository.Delete(group);
response.Data = _mapper.Map <GroupDto>(group);
}
}
return(response);
}
public override async Task <ErrorRepsonse <UserDto> > AddAsync(CreateUserDto createDto)
{
var response = new ErrorRepsonse <UserDto>();
if (await _repository.Any(c => c.UserName.ToLower() == createDto.UserName.ToLower()))
{
response.Errors.Add("UserName.Exisit");
return(response);
}
if (await _repository.Any(c => c.Name == createDto.Name))
{
response.Errors.Add("Name.Exisit");
return(response);
}
var user = _mapper.Map <User>(createDto);
await _repository.AddAsync(user);
response = new ErrorRepsonse <UserDto>(_mapper.Map <UserDto>(user));
if (user.CanWorkAsAgent)
{
RemoveCash();
}
return(response);
}