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