public async Task <EmployeeDto> CreateAsync(EmployeeDto employeeDto)
{
ThrowIfNull(employeeDto);
var department = await Uow.Departments.GetByIdAsync(employeeDto.DepartmentId);
if (department == null)
{
throw new ArgumentException($"Department with departmentId: '{employeeDto.DepartmentId}' not found", nameof(employeeDto.DepartmentId));
}
try
{
var employee = employeeDto.ToEntity();
employee.DepartmentId = department.Id;
employee.CompanyId = department.CompanyId;
Uow.Employees.Create(employee);
await Uow.CommitAsync();
return(employee.ToDto());
}
catch (Exception e)
{
Logger.LogError(e, "Error while creating employee");
throw;
}
}
public async Task DeleteFromProjectAsync(int employeeId, int projectId)
{
var employee = await Uow.Employees.GetByIdAsync(employeeId);
if (employee == null)
{
throw new ArgumentException($"Employee with employeeId: '{employeeId}' not found", nameof(employeeId));
}
var project = await Uow.Projects.GetByIdAsync(projectId);
if (project == null)
{
throw new ArgumentException($"Project with employeeId: '{employeeId}' not found", nameof(employeeId));
}
try
{
var employeeProject = project.EmployeeProjects.FirstOrDefault(x => x.EmployeeId.Equals(employeeId));
if (employeeProject != null)
{
project.EmployeeProjects.Remove(employeeProject);
await Uow.CommitAsync();
}
}
catch (Exception e)
{
Logger.LogError(e, $"Error while removing employee from project with EmployeeId: '{employeeId}' and ProjectId: '{projectId}'");
throw;
}
}
public async Task AddOrUpdateImageAsync(int id, string bucketName, byte[] imageData)
{
var employee = await Uow.Employees.GetByIdAsync(id);
if (employee == null)
{
throw new ArgumentException($"Employee with employeeId: '{id}' not found", nameof(id));
}
var fileName = string.Empty;
try
{
fileName = $"{id.ToString()}_avatar";
if (!string.IsNullOrEmpty(employee.ImageUrl))
{
await _blobStorageProvider.TryRemoveFileAsync(bucketName, fileName);
}
var imageUrl = await _blobStorageProvider.UploadFileAsync(bucketName, fileName, imageData);
employee.ImageUrl = imageUrl;
Uow.Employees.Edit(employee);
await Uow.CommitAsync();
}
catch (Exception e)
{
await _blobStorageProvider.TryRemoveFileAsync(bucketName, fileName);
Logger.LogError(e, $"Error while uploading employee's photo with EmployeeId: '{id}'");
throw;
}
}
public async Task EditAsync(int id, EmployeeDto employeeDto)
{
ThrowIfNull(employeeDto);
var employee = await Uow.Employees.GetByIdAsync(employeeDto.Id);
if (employee == null)
{
throw new ArgumentException($"Employee with employeeId: '{id}' not found", nameof(id));
}
var department = await Uow.Departments.GetByIdAsync(employeeDto.DepartmentId);
if (department == null)
{
throw new ArgumentException($"Department with departmentId: '{employee.DepartmentId}' not found", nameof(employee.DepartmentId));
}
try
{
employee.Name = employeeDto.Name;
employee.Surname = employeeDto.Surname;
employee.DepartmentId = department.Id;
Uow.Employees.Edit(employee);
await Uow.CommitAsync();
}
catch (Exception e)
{
Logger.LogError(e, $"Error while editing employee with employeeId: '{employeeDto.Id}'");
throw;
}
}
public async Task DeleteAsync(FashionSubCategory parameters)
{
var FashionSubCategory = Uow.Repository <FashionSubCategory>().FindByKey(parameters.FashionSubCategoryId);
await Uow.RegisterDeletedAsync(FashionSubCategory);
await Uow.CommitAsync();
}
public virtual async Task <HttpResponseMessage> Delete(object id)
{
Uow.GetRepositoryForEntityType <T>().Delete(id);
await Uow.CommitAsync();
return(new HttpResponseMessage(HttpStatusCode.NoContent));
}
public virtual async Task <HttpResponseMessage> Put(T entity)
{
Uow.GetRepositoryForEntityType <T>().Update(entity);
await Uow.CommitAsync();
return(new HttpResponseMessage(HttpStatusCode.NoContent));
}
public async Task DeleteAsync(vNotice parameters)
{
Notice notice = await this.Uow.Repository <Notice>().SingleOrDefaultAsync(t => t.NoticeId == parameters.NoticeId);
await Uow.RegisterDeletedAsync <Notice>(notice);
await Uow.CommitAsync();
}
public async Task DeleteAsync(UserAddress parameters)
{
var user = await Uow.Repository <AppUser>().FindByAsync(t => t.AppUserId == parameters.AppUserId);
await Uow.RegisterDeletedAsync(user);
await Uow.CommitAsync();
}
public async Task DeleteAsync(vEmployeeRec parameters)
{
Employee employee = await Uow.Repository <Employee>().SingleOrDefaultAsync(t => t.EmployeeId == parameters.EmployeeId);
await Uow.RegisterDeletedAsync <Employee>(employee);
await Uow.CommitAsync();
}
public async Task DeleteAsync(EducationDetail parameters)
{
// throw new NotImplementedException();
var del = await Uow.Repository <EducationDetail>().FindByAsync(r => r.EducationId == parameters.EducationId);
await Uow.RegisterDeletedAsync(del);
await Uow.CommitAsync();
}
public async Task DeleteAsync(FacebookUserWork parameters)
{
// throw new NotImplementedException();
var delete = await Uow.Repository <FacebookUserWork>().FindByAsync(m => m.UserWorkId == parameters.UserWorkId);
await Uow.RegisterDeletedAsync(delete);
await Uow.CommitAsync();
}
public async Task DeleteAsync(PostComment parameters)
{
var UserComment = Uow.Repository <PostComment>().FindByKey(parameters.PostCommentId);
await Uow.RegisterDeletedAsync(UserComment);
await Uow.CommitAsync();
// throw new NotImplementedException();
}
public async Task <GroupResponse> AddGroup(CreateGroupRequest request)
{
var group = Mapper.Map <CreateGroupRequest, TasksManager.Entities.Group>(request);
await Uow.Groups.AddAsync(group);
await Uow.CommitAsync();
return(Mapper.Map <TasksManager.Entities.Group, GroupResponse>(group));
}
public async Task UpdateAsync(FacebookUserModel entity)
{
FacebookUser facebookUser = new FacebookUser();
facebookUser.LoginStatus = entity.LoginStatus;
await Uow.RegisterDirtyAsync(facebookUser);
await Uow.CommitAsync();
}
public async Task DeleteAsync(LInkedInUserAuth parameters)
{
//var LinkedInUser = Uow.Repository<LinkedInUser>().FindByAsync(t=> t.LIUserId==parameters.LIUserId);
await Uow.RegisterDeletedAsync(parameters);
await Uow.CommitAsync();
//throw new NotImplementedException();
}
public async Task DeleteAsync(CreateBookBed parameters)
{
var candidate = Uow.Repository <BookBed>().FindByKey(parameters.BookBedId);
await Uow.RegisterDeletedAsync(candidate);
await Uow.CommitAsync();
//await Uow.Repository<CreateBookBed>().FindByAsync(a => a.BedId == parameters.BedId);
//throw new NotImplementedException();
}
public async Task UpdateAsync(Otp entity)
{
Random rnd = new Random();
string randomNumber = (rnd.Next(100000, 999999)).ToString();
entity.OtpCode = Int32.Parse(randomNumber);
await Uow.RegisterDirtyAsync(entity);
await Uow.CommitAsync();
}
public async Task DeleteAsync(PostTag parameters)
{
var PostTagged = Uow.Repository <PostTag>().FindByKey(parameters.PostTagId);
await Uow.RegisterDeletedAsync(PostTagged);
await Uow.CommitAsync();
parameters.TagStatus = "Off";
//throw new NotImplementedException();
}
public async Task DeleteAsync(Post parameters)
{
var UserPost = Uow.Repository <Post>().FindByKey(parameters.PostId);
await Uow.RegisterDeletedAsync(UserPost);
await Uow.CommitAsync();
parameters.Status = "Deactivated";
// throw new NotImplementedException();
}
public async Task DeleteAsync(BookEntery parameters)
{
BookDetail bookDetail = new BookDetail();
var candidate = Uow.Repository <BookEntery>().FindByKey(parameters.BookEnteryId);
await Uow.RegisterDeletedAsync(candidate);
await Uow.CommitAsync();
//throw new NotImplementedException();
}
public async Task AddAsync(User entity)
{
PasswordResult passwordResult = PasswordHash.Encrypt(entity.userPassword);
entity.Password = passwordResult.Signature;
entity.Salt = passwordResult.Salt;
await Uow.RegisterNewAsync(entity);
await Uow.CommitAsync();
}
public virtual async Task <HttpResponseMessage> Patch([FromBody] string json)
{
ExpandoObject expandoObject = JsonConvert.DeserializeObject <ExpandoObject>(json);
Uow.ValidateOnSaveEnabled(false);
Uow.GetRepositoryForEntityType <T>().Update(expandoObject);
await Uow.CommitAsync();
return(new HttpResponseMessage(HttpStatusCode.NoContent));
}
public async Task UpdateAsync(FacebookUserWork entity)
{
await Uow.RegisterDirtyAsync(entity);
await Uow.CommitAsync();
// var update = await Uow.Repository<FacebookUserWork>().FindByAsync(m => m.UserWorkId == entity.UserWorkId);
// await Uow.RegisterDirtyAsync(update);
//await Uow.CommitAsync();
}
public async Task AddAsync(BlockedUser entity)
{
if (entity.IsBlocked == true)
{
entity.UsercontactId = entity.BlockedUserId;
}
await Uow.RegisterNewAsync(entity);
await Uow.CommitAsync();
}
public async Task AddAsync(PostLike entity)
{
var count = Uow.Repository <PostLike>().Count(a => a.LikedById == entity.LikedById && a.PostId == entity.PostId);
if (count == 0)
{
await Uow.RegisterNewAsync(entity);
await Uow.CommitAsync();
}
}
public async Task UpdateAsync(UserAddress entity)
{
var user = await Uow.Repository <UserAddress>().FindByAsync(t => t.AppUserId == entity.AppUserId);
if (user != null)
{
await Uow.RegisterDirtyAsync(entity);
await Uow.CommitAsync();
}
}
public async Task AddAsync(User entity)
{
//var UserPassword = "******";
//PasswordResult passwordResult = PasswordHash.Encrypt(UserPassword);
//entity.Password = passwordResult.Signature;
//entity.Salt = passwordResult.Salt;
await Uow.RegisterNewAsync(entity);
await Uow.CommitAsync();
}
public async Task DeleteAsync(OTP parameters)
{
var currenttime = System.DateTime.Now;
if (parameters.DeactivateTime < currenttime)
{
var deactivateotp = Uow.Repository <OTP>().FindByKey(parameters.OTPId);
await Uow.RegisterDeletedAsync(deactivateotp);
await Uow.CommitAsync();
}
}
public async Task <object> GetBy(OTP parameters)
{
Random rand = new Random();
parameters.OtpNumber = rand.Next(1000, 9999);
parameters.ActivateTime = System.DateTime.Now;
parameters.DeactivateTime = parameters.ActivateTime.AddMinutes(2);
await Uow.RegisterNewAsync(parameters);
await Uow.CommitAsync();
return(await Task.FromResult(parameters.OTPId));
}
