public async Task UpdateFolder(UpdateFolderDto folderDto, int userId, int clientId)
{
var fileStorageRepository = DataContextManager.CreateRepository <IFileStorageRepository>();
var fileStorage = await fileStorageRepository.GetById(folderDto.Id, userId, clientId);
if (fileStorage == null || fileStorage != null && !fileStorage.IsDirectory)
{
throw new NotFoundException("File storage", folderDto.Id);
}
var isAvailableToChange = await fileStorageRepository.IsAvailableToChange(fileStorage.Id, userId, clientId);
if (!isAvailableToChange)
{
throw new UnavailableOperationException("update folder", "File storage", fileStorage.Id, userId);
}
if (fileStorage.ParentFileStorageId.HasValue)
{
var childFileStorages = await fileStorageRepository.GetByParentId(fileStorage.ParentFileStorageId.Value, userId, clientId);
if (childFileStorages.Any(x => x.Name.Equals(folderDto.Name) && x.Id != folderDto.Id))
{
throw new FoundSameObjectException("File storage", folderDto.Name);
}
}
fileStorage.Name = folderDto.Name;
fileStorage.UpdateById = userId;
fileStorage.UpdateDate = DateTime.UtcNow;
await fileStorageRepository.Update(fileStorage);
}
public void DeleteVehicles(IEnumerable <Int32> vehicleIDs)
{
var repository = DataContextManager.CreateRepository <ICargoRepository>();
repository.DeleteVehicles(vehicleIDs);
DataContextManager.Save();
}
public async Task AddFolder(AddFolderDto folderDto, int userId, int clientId)
{
var fileStorageRepository = DataContextManager.CreateRepository <IFileStorageRepository>();
var parentFileStorage = await fileStorageRepository.GetById(folderDto.ParentId, userId, clientId);
if (parentFileStorage == null || parentFileStorage != null && !parentFileStorage.IsDirectory)
{
throw new NotFoundException("File storage", folderDto.ParentId);
}
var childFileStorages = await fileStorageRepository.GetByParentId(parentFileStorage.Id, userId, clientId);
if (childFileStorages.Any(x => x.IsDirectory && x.Name.Equals(folderDto.Name)))
{
throw new FoundSameObjectException("File storage", folderDto.Name);
}
var owners = await _permissionHelper.GetOwners(parentFileStorage, userId, clientId);
var newFileStorage = new FileStorage
{
IsDirectory = true,
Name = folderDto.Name,
CreateDate = DateTime.UtcNow,
ParentFileStorageId = parentFileStorage.Id,
CreateById = userId,
ClientId = owners.ClientId,
OwnerId = owners.OwnerId,
IsActive = true
};
await fileStorageRepository.Add(newFileStorage);
}
public async Task <IEnumerable <CarGroupDto> > GetAll()
{
var carGroupRepository = DataContextManager.CreateRepository <ICarGroupRepository>();
var carGroups = await carGroupRepository.GetAll();
return(MapperFactory.CreateMapper <ICarGroupMapper>().MapCollectionToModel(carGroups));
}
public async Task <FolderDto> GetByChildId(int childId, int userId, int clientId)
{
var fileStorageHierarchyRepository = DataContextManager.CreateRepository <IFileStorageHierarchyRepository>();
var folderDto = await fileStorageHierarchyRepository.GetByChildId(childId, userId, clientId);
return(MapperFactory.CreateMapper <IFolderMapper>().MapToModel(folderDto));
}
public async Task <IEnumerable <FileStorageDto.StorageDto> > Search(AdvancedSearchDto advancedSearchDto, int userId, int clientId)
{
var fileStorageRepository = DataContextManager.CreateRepository <IFileStorageRepository>();
var fileStorages = await fileStorageRepository.GetQuery(userId, clientId, advancedSearchDto.FolderIds);
var resFileStorages = await fileStorages.GetForFileStorage(advancedSearchDto).ToListAsync();
var result = new List <FileStorage>();
if (advancedSearchDto.FolderIds.Count() > 0)
{
foreach (var fileStorage in resFileStorages)
{
var res = GetByParentIds(fileStorage, advancedSearchDto.FolderIds);
if (res != null)
{
result.Add(res);
}
}
}
else
{
result = resFileStorages;
}
return(MapperFactory.CreateMapper <IFileStorageMapper>().MapCollectionToModel(result));
}
public async Task <AppUserDto> Register(AppUserDto userDto)
{
var accountRepository = DataContextManager.CreateRepository <IAccountRepository>();
var user = await accountRepository.GetByEmail(userDto.Email);
if (user != null)
{
throw new ArgumentException(ErrorMessage.SAMENAME.ToString());
}
user = new AppUser
{
FirstName = userDto.FirstName,
LastName = userDto.LastName,
Email = userDto.Email,
Mobile = userDto.Mobile,
Password = GetMD5Hash(userDto.Password),
CreateDate = DateTime.Now,
IsActive = true
};
await accountRepository.Add(user);
return(MapperFactory.CreateMapper <IAppUserMapper>().MapToModel(user));
}
public async Task Update(UpdateDepartmentDto departmentDto)
{
var departmentRepository = DataContextManager.CreateRepository <IDepartmentRepository>();
var department = await departmentRepository.GetById(departmentDto.Id);
if (department == null)
{
throw new NotFoundException("Department", departmentDto.Id);
}
var clientRepository = DataContextManager.CreateRepository <IClientRepository>();
var client = await clientRepository.GetById(departmentDto.ClientId);
if (client == null)
{
throw new NotFoundDependencyObjectException("Client", departmentDto.ClientId);
}
var otherDepartment = client.Departments.FirstOrDefault(x => x.Name.Equals(departmentDto.Name) && x.IsActive);
if (otherDepartment != null && otherDepartment.Id != departmentDto.Id)
{
throw new FoundSameObjectException("Department", departmentDto.Name);
}
department.Name = departmentDto.Name;
department.UpdateDate = DateTime.UtcNow;
department.Client = client;
department.UpdateDate = DateTime.UtcNow;
await departmentRepository.Update(department);
}
public void AddDistrict(String districtName)
{
var repository = DataContextManager.CreateRepository <ICargoRepository>();
repository.AddDistrict(districtName);
DataContextManager.Save();
}
public async Task <IEnumerable <DepartmentDto> > GetByClientId(int clientId)
{
var departmentRepository = DataContextManager.CreateRepository <IDepartmentRepository>();
var departments = await departmentRepository.GetByClientId(clientId);
return(MapperFactory.CreateMapper <IDepartmentMapper>().MapCollectionToModel(departments));
}
public async Task <DownloadFileDto> GetFileById(int id, int userId, int clientId)
{
var fileStorageRepository = DataContextManager.CreateRepository <IFileStorageRepository>();
var fileStorage = await fileStorageRepository.GetById(id, userId, clientId);
if (fileStorage == null || fileStorage != null && fileStorage.IsDirectory)
{
throw new NotFoundException("File storage", id);
}
var file = fileStorage.Files.FirstOrDefault(x => x.IsActive);
if (file == null)
{
throw new NotFoundDependencyObjectException("File");
}
var buffer = await _azureBlobClient.DownloadFile(_blobSettings.ContainerName, file.AzureBlobStorage.BlobName.ToString());
return(new DownloadFileDto
{
Name = fileStorage.Name,
Extension = file.Extension,
Buffer = buffer
});
}
public async Task Update(CarSubgroupUpdateDto carSubgroupDto)
{
var carSubgroupRepository = DataContextManager.CreateRepository <ICarSubgroupRepository>();
var carSubgroup = await carSubgroupRepository.GetById(carSubgroupDto.Id);
if (carSubgroup == null)
{
throw new ObjectNotFoundException();
}
var carSubgroupWithSameName = await carSubgroupRepository.GetByName(carSubgroupDto.Name, carSubgroupDto.Id);
if (carSubgroupWithSameName != null)
{
throw new UpdatingException();
}
var carRepository = DataContextManager.CreateRepository <ICarRepository>();
var cars = await carRepository.GetCarsByIds(carSubgroupDto.CarIds);
carSubgroup.Name = carSubgroupDto.Name;
carSubgroup.UpdateDate = DateTime.Now;
AddCars(carSubgroup, cars);
DeleteCars(carSubgroup, cars);
await carSubgroupRepository.Update(carSubgroup);
}
public async Task <int> Add(AddUserGroupDto groupDto, int userId)
{
var userGroupRepository = DataContextManager.CreateRepository <IUserGroupRepository>();
var group = await userGroupRepository.GetByName(groupDto.Name, userId);
if (group != null)
{
throw new FoundSameObjectException("Group", groupDto.Name);
}
var users = await _userService.GetByIds(groupDto.UserIds);
var newGroup = new Group
{
OwnerId = userId,
Name = groupDto.Name,
UsersInGroup = users.Select(us => new UserInGroup
{
UserId = us.Id
})
.ToList(),
IsActive = true
};
await userGroupRepository.Add(newGroup);
return(newGroup.Id);
}
public async Task Add(CarSubgroupAddDto carSubgroupDto)
{
var carSubgroupRepository = DataContextManager.CreateRepository <ICarSubgroupRepository>();
var carSubgroup = await carSubgroupRepository.GetByName(carSubgroupDto.Name);
if (carSubgroup != null)
{
throw new AddingException();
}
var carRepository = DataContextManager.CreateRepository <ICarRepository>();
var cars = await carRepository.GetCarsByIds(carSubgroupDto.CarIds);
var newCarSubgroup = new CarSubgroup
{
Name = carSubgroupDto.Name,
CreateDate = DateTime.Now,
CarInCarSubgroups = cars.Select(car => new CarInCarSubgroup
{
Car = car
})
.ToList()
};
await carSubgroupRepository.Add(newCarSubgroup);
}
public async Task Add(AddDepartmentDto departmentDto)
{
var clientRepository = DataContextManager.CreateRepository <IClientRepository>();
var client = await clientRepository.GetById(departmentDto.ClientId);
if (client == null)
{
throw new NotFoundDependencyObjectException("Client", departmentDto.ClientId);
}
if (client.Departments.Where(x => x.IsActive).Select(s => s.Name).Contains(departmentDto.Name))
{
throw new FoundSameObjectException("Department", departmentDto.Name);
}
var department = new Department
{
Name = departmentDto.Name,
CreateDate = DateTime.UtcNow,
IsActive = true
};
client.Departments.Add(department);
await clientRepository.Update(client);
}
public async Task AddFile(AddFileDto fileDto, int userId, int clientId)
{
var fileStorageRepository = DataContextManager.CreateRepository <IFileStorageRepository>();
var parentFileStorage = await fileStorageRepository.GetById(fileDto.ParentId, userId, clientId);
if (parentFileStorage == null || !parentFileStorage.IsDirectory)
{
throw new NotFoundException("File storage", fileDto.ParentId);
}
var fileName = Path.GetFileNameWithoutExtension(fileDto.Name);
var fileExtension = Path.GetExtension(fileDto.Name);
var childFileStorages = await fileStorageRepository.GetByParentId(parentFileStorage.Id, userId, clientId);
if (childFileStorages.Any(x => !x.IsDirectory && x.Name.Equals(fileName) &&
x.Files.Any(y => y.IsActive && y.Extension.Equals(fileExtension))))
{
throw new FoundSameObjectException("File storage", fileName);
}
var owners = await _permissionHelper.GetOwners(parentFileStorage, userId, clientId);
var sizeInfo = fileDto.Size.ToPrettySize();
var blobName = Guid.NewGuid();
var newFileStorage = new FileStorage
{
Name = fileName,
ParentFileStorageId = parentFileStorage.Id,
IsDirectory = false,
CreateDate = DateTime.UtcNow,
CreateById = userId,
ClientId = owners.ClientId,
OwnerId = owners.OwnerId,
IsActive = true,
Files = new List <Models.File>
{
new Models.File
{
Extension = fileExtension,
Size = sizeInfo.Size,
SizeType = sizeInfo.SizeType,
IsActive = true,
CreateById = userId,
CreateDate = DateTime.UtcNow,
AzureBlobStorage = new AzureBlobStorage
{
BlobName = blobName
}
}
}
};
await _azureBlobClient.UploadFile(_blobSettings.ContainerName, blobName.ToString(), fileDto.Content.ToByteArray());
await fileStorageRepository.Add(newFileStorage);
}
public async Task <CheckPermissionResultDto> RemovePermission(RemovePermissionDto permissionDto, int userId, int clientId)
{
var fileStorageRepository = DataContextManager.CreateRepository <IFileStorageRepository>();
var fileStorage = await fileStorageRepository.GetById(permissionDto.FileStorageId, userId, clientId);
var isAvailableToChange = await fileStorageRepository.IsAvailableToChange(fileStorage.Id, userId, clientId);
if (!isAvailableToChange)
{
throw new UnavailableOperationException("remove permission", "Permission", fileStorage.Id, userId);
}
var sender = await _userService.GetById(userId);
var recipient = await _userService.GetById(permissionDto.RecipientId);
var fileStoragePermission = fileStorage.Permissions.FirstOrDefault(x => x.RecipientId == recipient.Id && !x.EndDate.HasValue);
if (fileStoragePermission == null)
{
throw new NotFoundException("File storage permission", fileStorage.Id, recipient.Email);
}
fileStoragePermission.EndDate = DateTime.UtcNow;
var parentFileStorages = await fileStorageRepository.GetParents(fileStorage.ParentFileStorageId, userId, clientId);
if (!fileStorage.ClientId.HasValue && !fileStorage.OwnerId.HasValue || fileStorage.ClientId.HasValue && !fileStorage.OwnerId.HasValue)
{
parentFileStorages.ToList()
.ForEach(storage =>
{
var permission = storage.Permissions.FirstOrDefault(x => x.RecipientId == recipient.Id && !x.EndDate.HasValue);
if (permission != null)
{
permission.EndDate = DateTime.UtcNow;
}
});
}
await SaveChanges(fileStorageRepository, fileStorage, parentFileStorages);
return(new CheckPermissionResultDto
{
Storage = MapperFactory.CreateMapper <IFileStorageMapper>().MapToModel(fileStorage),
Sender = sender,
Recipients = new List <CheckPermissionResultDto.RecipientDto>
{
new CheckPermissionResultDto.RecipientDto
{
Id = recipient.Id,
UserName = recipient.UserName,
Email = recipient.Email,
Type = CheckPermissionResultDto.UpdateType.Remove
}
}
});
}
public async Task <AppUserDto> GetUserByEmail(string email)
{
var accountRepository = DataContextManager.CreateRepository <IAccountRepository>();
var user = await accountRepository.GetByEmail(email);
return(MapperFactory.CreateMapper <IAppUserMapper>().MapToModel(user));
}
public async Task <IEnumerable <ClientDto> > GetAll()
{
var clientRepository = DataContextManager.CreateRepository <IClientRepository>();
var clients = await clientRepository.GetAll();
return(MapperFactory.CreateMapper <IClientMapper>().MapCollectionToModel(clients));
}
public async Task <IEnumerable <Dto> > GetAll()
{
var repository = DataContextManager.CreateRepository <ICommonRepository <TEntity> >();
var entities = await repository.GetAll();
return(MapperFactory.CreateMapper <ICommonMapper <TEntity, Dto> >().MapCollectionToModel(entities));
}
public async Task <IEnumerable <UserGroupDto> > GetGroups(int userId)
{
var userGroupRepository = DataContextManager.CreateRepository <IUserGroupRepository>();
var groups = await userGroupRepository.GetGroups(userId);
return(MapperFactory.CreateMapper <IUserGroupMapper>().MapCollectionToModel(groups));
}
public IEnumerable <VehicleDto> GetVehiclesByPhone(String phone)
{
var repository = DataContextManager.CreateRepository <ICargoRepository>();
var mapper = MapperFactory.CreateMapper <IVehicleMapper>();
var data = repository.GetVehiclesByPhone(phone);
var result = mapper.MapCollectionToModel <VehicleDto>(data);
return(result);
}
public IEnumerable <DistrictDto> GetDistricts()
{
var repository = DataContextManager.CreateRepository <ICargoRepository>();
var mapper = MapperFactory.CreateMapper <IDistrictMapper>();
var data = repository.GetDistricts();
var result = mapper.MapCollectionToModel <DistrictDto>(data);
return(result);
}
public DistrictDto GetDistrictByID(Int32 districtID)
{
var repository = DataContextManager.CreateRepository <ICargoRepository>();
var mapper = MapperFactory.CreateMapper <IDistrictMapper>();
var data = repository.GetDistrictByID(districtID);
var result = mapper.MapToModel(data);
return(result);
}
public async Task AddCar(CarAddDto carDto)
{
var carRepository = DataContextManager.CreateRepository <ICarRepository>();
var car = MapperFactory.CreateMapper <ICarAddMapper>().MapFromModel(carDto);
car.CarBusiness.CreateDate = DateTime.Now;
await carRepository.AddCar(car);
}
public override void Dispose()
{
if (this._dcManager != null)
{
this._dcManager.Dispose();
this._dcManager = null;
}
base.Dispose();
}
public void AddVehicle(VehicleDto model)
{
var result = String.Empty;
var repository = DataContextManager.CreateRepository <ICargoRepository>();
var mapper = MapperFactory.CreateMapper <IVehicleMapper>();
var data = mapper.MapFromModel(model);
repository.AddVehicle(data);
DataContextManager.Save();
}
public async Task <IEnumerable <UserDto> > GetByGroupIds(IEnumerable <int> groupIds)
{
var userGroupRepository = DataContextManager.CreateRepository <IUserGroupRepository>();
var groups = await userGroupRepository.GetByIds(groupIds);
var users = groups.SelectMany(s => s.UsersInGroup).Select(s => s.User).Where(x => x.IsActive).ToList();
return(MapperFactory.CreateMapper <IUserMapper>().MapCollectionToModel(users));
}
public async Task <UserGroupDto> GetById(int groupId, int userId)
{
var userGroupRepository = DataContextManager.CreateRepository <IUserGroupRepository>();
var group = await userGroupRepository.GetById(groupId, userId);
if (group == null)
{
throw new NotFoundException("Group", groupId);
}
return(MapperFactory.CreateMapper <IUserGroupMapper>().MapToModel(group));
}
private async Task <Client> GetClientById(int id)
{
var clientRepository = DataContextManager.CreateRepository <IClientRepository>();
var client = await clientRepository.GetById(id);
if (client == null)
{
throw new NotFoundDependencyObjectException("Client", id);
}
return(client);
}
