void EmptyTheDatabase() { var repository = new WriteRepository(new ConfigConnectionSettings("rel")); repository.Do("TRUNCATE TABLE [Beds]", Enumerable.Empty<KeyValuePair<string, object>>()); repository.Do("TRUNCATE TABLE [Participants]", Enumerable.Empty<KeyValuePair<string, object>>()); repository.Do("TRUNCATE TABLE [ParticipantsRetreats]", Enumerable.Empty<KeyValuePair<string, object>>()); repository.Do("TRUNCATE TABLE [Retreats]", Enumerable.Empty<KeyValuePair<string, object>>()); }
static void Main(string[] args) { var readRepository = new ReadRepository(new ConfigConnectionSettings("event")); var writeRepository = new WriteRepository(new ConfigConnectionSettings("event")); var binaryFormatter = new BinaryFormatter(); var snapshots = readRepository.All("SELECT * FROM [Snapshots] ORDER BY [DateTime]", Enumerable.Empty<KeyValuePair<string, object>>()); foreach (var snapshot in snapshots) { var actual = binaryFormatter.Deserialize(new MemoryStream((byte[])snapshot.Snapshot)) as Event; var stream = new MemoryStream(); new XmlSerializer(actual.GetType()).Serialize(stream, actual); var content = stream.ToArray(); var xmlpair = new KeyValuePair<string, object>("@Xml", content); var typepair = new KeyValuePair<string, object>("@Type", actual.ToString()); var idpair = new KeyValuePair<string, object>("@Id", snapshot.Id); writeRepository.Do("UPDATE [Snapshots] SET [SnapshotXml] = @Xml, [Type] = @Type WHERE [Id] = @Id", new[] { xmlpair, typepair, idpair }); } var events = readRepository.All("SELECT * FROM [Events] ORDER BY [DateTime]", Enumerable.Empty<KeyValuePair<string, object>>()); foreach (var @event in events) { var actual = binaryFormatter.Deserialize(new MemoryStream((byte[])@event.Event)) as Event; var stream = new MemoryStream(); new XmlSerializer(actual.GetType()).Serialize(stream, actual); var content = stream.ToArray(); var xmlpair = new KeyValuePair<string, object>("@Xml", content); var typepair = new KeyValuePair<string, object>("@Type", actual.ToString()); var idpair = new KeyValuePair<string, object>("@Id", @event.Id); System.Threading.Thread.Sleep(10); writeRepository.Do("UPDATE [Events] SET [EventXml] = @Xml, [Type] = @Type WHERE [Id] = @Id", new[] { xmlpair, typepair, idpair }); } }
/// <summary> /// Add Site /// </summary> /// <param name="userId"></param> /// <param name="request"></param> /// <returns></returns> public async Task <TResponse <bool> > Add(int userId, InsertSiteModel request) { try { var canInsert = await CanInsert(request); if (canInsert.IsSuccess) { var result = await WriteRepository.ExecuteScalarAsync <int>(SqlQuery.SITE_INSERT, new { request.Id, request.SiteCode, request.SiteName, UserCreated = userId, UserUpdated = userId }); if (result.IsSuccess) { if (result.Data == 0) { return(await Fail <bool>(string.Format(ErrorEnum.SqlQueryCanNotExecute.GetStringValue(), "SITE_INSERT"))); } return(await Ok(true)); } return(await Fail <bool>(result.Message)); } return(await Fail <bool>(canInsert.Message)); } catch (Exception exception) { return(await Fail <bool>(exception)); } }
public override async Task <int> AddAsync(CarStockCreateCommand createCommand) { await ValidatorFactory.GetValidator <CarStockCreateCommand>().ValidateAndThrowAsync(createCommand); using (await BusinessLocks.CarStockLock.LockAsync()) { var car = await _readRepository.GetSingleAsync(_carStockFiltersProvider.MatchAll(createCommand.ModelId, createCommand.BodyTypeId, createCommand.ColorId, createCommand.EngineGearboxId, createCommand.ComplectationId)); if (car == null) { car = Mapper.Map <CarStock>(createCommand); car.Price = await _carStockCommandRepository.CalculateCarPriceAsync(car.ModelId, car.BodyTypeId, car.EngineGearboxId, car.ComplectationId); await WriteRepository.AddAsync(car); await UnitOfWork.CommitAsync(); } return(car.Id); } }
public void AddAsync_Should_Add_Data_And_Should_Return_Exptected(Mock <ISessionManager> mockSessionManager, DefaultSession session, Dummy data) { //Arrange mockSessionManager.Setup(m => m.Current) .Returns(session); var options = new DbContextOptionsBuilder <DummyContext>() .UseInMemoryDatabase("DummyDb") .Options; //Act var context = new DummyContext(options, mockSessionManager.Object); var repository = new WriteRepository <DummyContext, Dummy>(context); repository.AddAsync(data); //Assert Dummy dummyData = repository.GetById(data.Id); dummyData.Should().BeEquivalentTo(data); context.Dispose(); }
/// <summary> /// Change User Password /// </summary> /// <param name="userId"></param> /// <param name="id"></param> /// <param name="password"></param> /// <returns></returns> public async Task <TResponse <bool> > ChangePassword(int userId, int id, string password) { try { var canChangePassword = await CanChangePassword(id); if (canChangePassword.IsSuccess) { var result = await WriteRepository.ExecuteAsync(SqlQuery.USER_CHANGE_PASSWORD, new { Id = id, Password = Sha512(password), UserUpdated = userId }); if (result.IsSuccess) { if (result.Data > 0) { return(await Ok(true)); } return(await Fail <bool>(string.Format(ErrorEnum.SqlQueryCanNotExecute.GetStringValue(), "USER_CHANGE_PASSWORD"))); } return(await Fail <bool>(result.Message)); } return(await Fail <bool>(canChangePassword.Message)); } catch (Exception exception) { return(await Fail <bool>(exception)); } }
public async Task <TResponse <bool> > UpdateInformation(UserDto user) { try { var canUpdate = await GetById(user.Id); if (canUpdate.IsSuccess) { var result = await WriteRepository.ExecuteAsync(SqlQuery.USER_UPDATE_INFORMATION, new { user.Id, user.Email, user.Name, user.Phone, UserUpdated = user.Id }); if (result.IsSuccess) { if (result.Data > 0) { return(await Ok(true)); } return(await Fail <bool>(string.Format(ErrorEnum.SqlQueryCanNotExecute.GetStringValue(), "USER_UPDATE_INFORMATION"))); } return(await Fail <bool>(result.Message)); } return(await Fail <bool>(canUpdate.Message)); } catch (Exception exception) { return(await Fail <bool>(exception)); } }
public async Task <TResponse <bool> > ResetPassword(int userId, int id) { try { var canResetPassword = await CanResetPassword(userId, id); if (canResetPassword.IsSuccess) { var result = await WriteRepository.ExecuteAsync(SqlQuery.USER_CHANGE_PASSWORD, new { Id = id, Password = Sha512("123456") }); if (result.IsSuccess) { if (result.Data > 0) { return(await Ok(true)); } return(await Fail <bool>(ErrorEnum.BAD_REQUEST.GetStringValue())); } return(await Fail <bool>(result.Message)); } return(await Fail <bool>(canResetPassword.Message)); } catch (Exception exception) { return(await Fail <bool>(exception)); } }
/// <summary> /// Update Role /// </summary> /// <param name="userId"></param> /// <param name="request"></param> /// <returns></returns> public async Task <TResponse <bool> > Update(int userId, UpdateRoleModel request) { try { var canUpdate = await CanUpdate(request); if (canUpdate.IsSuccess) { var result = await WriteRepository.ExecuteAsync(SqlQuery.ROLE_UPDATE, new { request.Id, request.Name, request.Description, UserUpdated = userId }); if (result.IsSuccess) { if (result.Data == 0) { return(await Fail <bool>(string.Format(ErrorEnum.SqlQueryCanNotExecute.GetStringValue(), "ROLE_UPDATE"))); } return(await Ok(true)); } return(await Fail <bool>(result.Message)); } return(await Fail <bool>(canUpdate.Message)); } catch (Exception exception) { return(await Fail <bool>(exception)); } }
public async Task <TResponse <bool> > ChangePassword(string username, string currentPassword, string password) { try { var checkPassword = await CheckInvalidPassword(username, currentPassword); if (checkPassword.IsSuccess) { var result = await WriteRepository.ExecuteAsync(SqlQuery.USER_UPDATED_PASSWORD, new { Id = checkPassword.Data, Password = Sha512(password), UserUpdated = checkPassword.Data }); if (result.IsSuccess) { if (result.Data > 0) { return(await Ok(true)); } return(await Fail <bool>(string.Format(ErrorEnum.SqlQueryCanNotExecute.GetStringValue(), "USER_UPDATED_PASSWORD"))); } return(await Fail <bool>(result.Message)); } return(await Fail <bool>(checkPassword.Message)); } catch (Exception exception) { return(await Fail <bool>(exception)); } }
public async Task <IHttpActionResult> Register(RegisterBindingModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } // create user User _user = new User { FirstName = model.FirstName, LastName = model.LastName, Email = model.Email, PhoneNumber = model.PhoneNumber, UserType = model.UserType, CreationDate = DateTime.Now }; // attach user using (IWriteUnitOfWork writeUnitOfWork = new WriteUnitOfWork()) { var repository = new WriteRepository <User, int>(writeUnitOfWork); repository.Attach(_user); repository.UnitOfWork.SaveChanges(); } var user = new ApplicationUser() { UserName = model.Email, Email = model.Email, UserId = _user.Id }; IdentityResult result = await UserManager.CreateAsync(user, model.Password); if (!result.Succeeded) { return(GetErrorResult(result)); } return(Ok()); }
public async Task<TResponse<bool>> Add(InsertNotificationModel request) { try { var result = await WriteRepository.ExecuteAsync(SqlQuery.NOTIFICATION_INSERT, new { request.UserId, request.UserReceiveId, request.Title, request.Message, request.Action, request.Type, request.Status, DateCreated = DateTime.Now, DateUpdated = request.Status == 0 ? null : (DateTime?) DateTime.Now }); if(result.IsSuccess) { if(result.Data > 0) { return await Ok(true); } return await Fail<bool>(ErrorEnum.BAD_REQUEST.GetStringValue()); } return await Fail<bool>(result.Message); } catch (Exception exception) { return await Fail<bool>(exception); } }
public void Add_Should_Dont_Save_Context_When_AutoSave_Is_False(Mock <ISessionManager> mockSessionManager, DefaultSession session, Dummy data) { //Arrange mockSessionManager.Setup(m => m.Current) .Returns(session); var options = new DbContextOptionsBuilder <DummyContext>() .UseInMemoryDatabase("DummyDb") .Options; //Act var context = new DummyContext(options, mockSessionManager.Object); var repository = new WriteRepository <DummyContext, Dummy>(context); repository.AutoSave = false; repository.Add(data); //Assert Dummy dummyData = repository.GetById(data.Id); dummyData.Should().BeNull(); context.Dispose(); }
private void button1_Click(object sender, EventArgs e) { WriteRepository repository = new WriteRepository(); var index = 0; if (!editmode) { Payroll model = new Payroll { Name = txtName.Text }; txtPayrollId.Text = repository.InsertPayroll(model).ToString(); index = comboBox1.Items.Count; } else { repository.UpdatePayroll(txtPayrollId.ToInt(), txtName.Text); index = comboBox1.SelectedIndex; } comboBox1.DataSource = null; comboBox1.Items.Clear(); LoadCombos(); comboBox1.SelectedIndex = index; }
public void GetByFirstNameAsyncShouldReturnCoach(string emailAddres, string login, string password, string firstName, string lastName, string preSharedKey) { var email = Email.Create(emailAddres); var aggregateRoot = Coach.Create(login, password, firstName, lastName, preSharedKey, email); Expression <Func <Coach, bool> > predictate = (x) => x.FirstName == firstName; using (var context = new DataBaseContext(options)) { context.Coaches.Add(aggregateRoot); context.Coaches.Add(additionalCoach); context.SaveChanges(); var coachesRepository = new WriteRepository <Coach>(context); var coach = coachesRepository .GetByAsync(predictate, new string[] { }, It.IsAny <CancellationToken>()) .GetAwaiter() .GetResult(); Assert.AreSame(coach, aggregateRoot); Assert.AreEqual(coach, aggregateRoot); } }
public async Task Update(int crmId, List <int> userIds, int type, int userUpdated) { var crmUsers = await LoadFromRedis(); var existUserIds = crmUsers.Where(c => c.CrmId == crmId && c.Type == type) .Select(c => c.UserId); foreach (var userId in userIds) { if (!existUserIds.Contains(userId)) { //them moi var result = await WriteRepository.ExecuteScalarAsync <int>(SqlQuery.INSERT_CRM_USER, new { CrmId = crmId, UserId = userId, Type = type, UserCreated = userUpdated, DateCreated = DateTime.Now, UserUpdated = userUpdated, DateUpdated = DateTime.Now }); if (result.IsSuccess) { if (result.Data > 0) { crmUsers.Add(new CrmUserCacheModel { Id = result.Data, CrmId = crmId, UserId = userId, Type = type }); } } } } foreach (var existUserId in existUserIds) { if (!userIds.Contains(existUserId)) { //xoa bo var result = await WriteRepository.ExecuteAsync(SqlQuery.REMOVE_CRM_USER, new { CrmId = crmId, UserId = existUserId, Type = type, UserUpdated = userUpdated, DateUpdated = DateTime.Now }); if (result.IsSuccess) { if (result.Data > 0) { var crmUser = crmUsers.FirstOrDefault(c => c.CrmId == crmId && c.UserId == existUserId && c.Type == type); if (crmUser != null) { crmUsers.Remove(crmUser); } } } } } await DistributedCache.Set(_cacheKey, crmUsers); }
public DahliaEventStore() { readRepository = new ReadRepository(new ConfigConnectionSettings("event")); writeRepository = new WriteRepository(new ConfigConnectionSettings("event")); }
public async Task <TResponse <bool> > Update(int userId, UpdateCrmStatusModel request, int permissionId) { try { var checkValid = await _userService.CheckPermission(userId, permissionId); if (checkValid.IsSuccess) { var canUpdate = await CanUpdate(request); if (canUpdate.IsSuccess) { var result = await WriteRepository.ExecuteAsync(SqlQuery.CRM_STATUS_UPDATE, new { request.Id, request.Name, request.Color, request.IsSendSms, request.SmsContent, UserUpdated = userId, DateUpdated = DateTime.Now }); if (result.IsSuccess) { if (result.Data > 0) { #region Update redis cache await _crmStatusCacheService.AddOrUpdate(new CrmStatusCacheModel { Id = request.Id, Name = request.Name, Color = request.Color, SmsContent = request.SmsContent, IsSendSms = request.IsSendSms }); #endregion return(await Ok(true)); } return(await Fail <bool>(ErrorEnum.BAD_REQUEST.GetStringValue())); } return(await Fail <bool>(result.Message)); } return(await Fail <bool>(canUpdate.Message)); } return(await Fail <bool>(checkValid.Message)); } catch (Exception exception) { return(await Fail <bool>(exception)); } }
public async Task <TResponse <bool> > Add(int userId, InsertTaskStatusModel request, int permissionId) { try { var checkValid = await _userService.CheckPermission(userId, permissionId); if (checkValid.IsSuccess) { var canInsert = await CanInsert(request); if (canInsert.IsSuccess) { var result = await WriteRepository.ExecuteScalarAsync <int>(SqlQuery.TASK_STATUS_INSERT, new { request.Name, request.Color, request.SortOrder, request.IsSendSms, request.SmsContent, UserCreated = userId, DateCreated = DateTime.Now, UserUpdated = userId, DateUpdated = DateTime.Now }); if (result.IsSuccess) { if (result.Data > 0) { #region Update redis cache await _taskStatusCacheService.AddOrUpdate(new TaskStatusCacheModel { Id = result.Data, Name = request.Name, Color = request.Color, SortOrder = request.SortOrder, IsSendSms = request.IsSendSms, SmsContent = request.SmsContent }); #endregion return(await Ok(true)); } return(await Fail <bool>(ErrorEnum.BAD_REQUEST.GetStringValue())); } return(await Fail <bool>(result.Message)); } return(await Fail <bool>(canInsert.Message)); } return(await Fail <bool>(checkValid.Message)); } catch (Exception exception) { return(await Fail <bool>(exception)); } }
public async Task <TResponse <bool> > Update(int userId, UpdateBranchModel request, int permissionId) { try { var checkValid = await _userService.CheckPermission(userId, permissionId); if (checkValid.IsSuccess) { var canUpdate = await CanUpdate(request); if (canUpdate.IsSuccess) { var result = await WriteRepository.ExecuteAsync(SqlQuery.BRANCH_UPDATE, new { request.Id, request.Name, request.Hotline, request.Address, request.ProvinceId, request.DistrictId, request.WardId, UserUpdated = userId, DateUpdated = DateTime.Now }); if (result.IsSuccess) { if (result.Data > 0) { #region Update redis cache await _branchCacheService.AddOrUpdate(new BranchCacheModel { Id = request.Id, Name = request.Name, Hotline = request.Hotline, ProvinceId = request.ProvinceId, DistrictId = request.DistrictId, WardId = request.WardId, Address = request.Address }); #endregion return(await Ok(true)); } return(await Fail <bool>(ErrorEnum.BAD_REQUEST.GetStringValue())); } return(await Fail <bool>(result.Message)); } return(await Fail <bool>(canUpdate.Message)); } return(await Fail <bool>(checkValid.Message)); } catch (Exception exception) { return(await Fail <bool>(exception)); } }
public FormSellerPanel(Seller currentSeller, KamilCieślikLab4PdContext context, ReadRepository <MenuProduct> readMenuProductRepository, WriteRepository <Order> writeOrderRepository) { _products = new List <MenuProduct>(); _context = context; _readMenuProductRepository = readMenuProductRepository; _writeOrderRepository = writeOrderRepository; _currentSeller = currentSeller; InitializeComponent(); SetCurrentSellerName(); }
public void CreateSprint(SprintEntity sprint) { WriteRepository.Add(sprint); }
public void UpdateSprint(SprintEntity sprint) { WriteRepository.Update(sprint); }
public async Task <TResponse <bool> > Update(int userId, UpdateAppConfigModel request, int permissionId) { try { var checkValid = await _userService.CheckPermission(userId, permissionId); if (checkValid.IsSuccess) { var canUpdate = await CanUpdate(request); if (canUpdate.IsSuccess) { var result = await WriteRepository.ExecuteAsync(SqlQuery.APP_CONFIG_UPDATE, new { request.Id, request.Name, request.Value, request.Description, UserUpdated = userId, DateUpdated = DateTime.Now }); if (result.IsSuccess) { if (result.Data > 0) { #region Update redis cache await _appConfigCacheService.AddOrUpdate(new AppConfigCacheModel { Id = request.Id, Name = request.Name, Value = request.Value, Description = request.Description }); #endregion return(await Ok(true)); } return(await Fail <bool>(ErrorEnum.BAD_REQUEST.GetStringValue())); } return(await Fail <bool>(result.Message)); } return(await Fail <bool>(canUpdate.Message)); } return(await Fail <bool>(checkValid.Message)); } catch (Exception exception) { return(await Fail <bool>(exception)); } }
public AccountController() { _readRepo = new ReadRepository(path); _writeRepo = new WriteRepository(path); }
public HomeController() { _readRepo = new ReadRepository(); _writeRepo = new WriteRepository(); }
public async Task DeleteSprintAsync(int sprintId) { var sprint = await ReadRepository.Query.SingleOrDefaultAsync(s => s.Id == sprintId); WriteRepository.Delete(sprint); }
public override void Proceseaza(Eveniment e) { var repo = new WriteRepository(); repo.SalvareEvenimente(e); }
private void button1_Click(object sender, EventArgs e) { var model = new Contractor(); model.ID = txtId.ToInt(); model.Name = txtName.Text; model.Surname = txtSurname.Text; if (txtRate.Text != "") { model.Rate = txtRate.ToDouble(); } if (txtOvertimeRate.Text != "") { model.Overtime_Rate = txtOvertimeRate.ToDouble(); } model.Agency = txtAgency.Text; model.Agency2 = txtAgency2.Text; if (txtNumber.Text != "") { model.Number = txtNumber.ToDouble(); } model.Info = txtInfo.Text; model.Time_sheet_submitted = txtTimeSheetSubmitted.Text; model.Companyname = txtCompanyName.Text; if (txtCompanyNumber.Text != "") { model.Company_Number = txtCompanyNumber.ToInt(); } model.Address1 = txtAddress1.Text; model.Address2 = txtAddress2.Text; model.Address3 = txtAddress3.Text; model.Address4 = txtAddress4.Text; model.Email = txtEmail.Text; if (txtStandardMargin.Text != "") { model.Standard_margin = txtStandardMargin.ToDouble(); } if (txtOvertimeMargin.Text != "") { model.overtimeMargin = txtOvertimeMargin.ToInt(); } model.Work_Permit = chkWorkPermit.Checked; model.charity = chkCharity.Checked; model.Daily_rate = chkDaily.Checked; model.Hourly_rate = chkHourly.Checked; model.selfbilling = chkSelfBilling.Checked; model.Bite_Employee = chkBiteEmployee.Checked; model.InvoiceID = Convert.ToInt16(cboInvoiced.SelectedValue); model.ContractorTypeID = Convert.ToInt16(cboContractorType.SelectedValue); model.Company = Convert.ToInt16(cboCompany.SelectedValue); model.Payroll = Convert.ToInt16(cboPayroll.SelectedValue); WriteRepository repository = new WriteRepository(); repository.UpdateContractor(model); repository = null; }
public async Task <TResponse <bool> > Update(int userId, UpdateUserModel request, int permissionId, string path) { try { var checkValid = await CheckPermission(userId, permissionId); if (checkValid.IsSuccess) { var canUpdate = await CanUpdate(request); if (canUpdate.IsSuccess) { string avatar = string.Empty; var image = request.Avatar; if (image != null && image.Length > 0) { avatar = $"{request.Username}.png"; } var result = await WriteRepository.ExecuteAsync(SqlQuery.USER_UPDATE, new { request.Id, request.DisplayName, request.FullName, request.Email, request.PhoneNumber, request.BranchId, request.RoleId, Avatar = avatar, UserUpdated = userId, DateUpdated = DateTime.Now }); if (result.IsSuccess) { if (result.Data > 0) { string message = string.Empty; if (image != null && image.Length > 0) { try { if (!Directory.Exists(path)) { Directory.CreateDirectory(path); } using (FileStream fileStream = File.Create(Path.Combine(path, request.Username) + ".png")) { image.CopyTo(fileStream); fileStream.Flush(); } } catch (Exception ex) { message = ex.ToString(); } } #region Update redis cache await _userCacheService.AddOrUpdate(new UserCacheModel { Id = request.Id, Username = request.Username, DisplayName = request.DisplayName, Email = request.Email, PhoneNumber = request.PhoneNumber, FullName = request.FullName }); #endregion return(await Ok(true, message)); } return(await Fail <bool>(ErrorEnum.BAD_REQUEST.GetStringValue())); } return(await Fail <bool>(result.Message)); } return(await Fail <bool>(canUpdate.Message)); } return(await Fail <bool>(checkValid.Message)); } catch (Exception exception) { return(await Fail <bool>(exception)); } }
public HomeController(ReadRepository readRepo, WriteRepository writeRepo) { _readRepo = readRepo; _writeRepo = writeRepo; }
private void Save(bool update) { if (txtYear.Text == "0" || txtYear.Text == "") { return; } HDM record; if (update) { record = new LookupRepository().GetHDM(queryResult[currentMonth].HDM); } else { record = new HDM(); } record.ContractorId = Convert.ToInt16(comboBox1.SelectedValue); record.Month = Convert.ToInt16(cboMonths.SelectedValue); record.hourlyrate1 = record.hourlyrate2 = record.hourlyrate3 = record.hourlyrate4 = record.hourlyrate5 = currentContractor.Hourly_rate; record.dailyrate1 = record.dailyrate2 = record.dailyrate3 = record.dailyrate4 = record.dailyrate5 = currentContractor.Daily_rate; record.Week1PayRate = currentContractor.Rate - currentContractor.Standard_margin; record.Week2PayRate = record.Week3PayRate = record.Week4PayRate = record.Week5PayRate = record.Week1PayRate; record.C0Week1PayRate = record.C0Week2PayRate = record.C0Week3PayRate = record.C0Week4PayRate = record.C0Week5PayRate = currentContractor.Overtime_Rate - currentContractor.Overtime_Rate; record.Holdmargin = currentContractor.Standard_margin; record.Week1 = txtWeek1.ToDouble(); record.Week2 = txtWeek2.ToDouble(); record.Week3 = txtWeek3.ToDouble(); record.Week4 = txtWeek4.ToDouble(); record.Week5 = txtWeek5.ToDouble(); record.O_Week1 = txtOWeek1.ToDouble(); record.O_Week2 = txtOWeek2.ToDouble(); record.O_Week3 = txtOWeek3.ToDouble(); record.O_Week4 = txtOWeek4.ToDouble(); record.O_Week5 = txtOWeek5.ToDouble(); record.Week1Rate = txtWeek1Rate.ToDouble(); record.Week2Rate = txtWeek2Rate.ToDouble(); record.Week3Rate = txtWeek3Rate.ToDouble(); record.Week4rate = txtWeek4Rate.ToDouble(); record.Week5rate = txtWeek5Rate.ToDouble(); record.Oweekrate = txtOWeek1Rate.ToDouble(); record.oweek2rate = txtOWeek2Rate.ToDouble(); record.oweek3rate = txtOWeek3Rate.ToDouble(); record.oweek4rate = txtOWeek4Rate.ToDouble(); record.oweek5rate = txtOWeek5Rate.ToDouble(); record.hoursworked = txtHours.ToDouble(); record.Overtimeworked = txtOTime.ToDouble(); record.daysworked = txtDays.ToDouble(); record.Total_Expenses = txtExpenses.ToDouble(); record.ClientExpenses = txtClientExpenses.ToDouble(); record.Advance = txtAdvance.ToDouble(); record.Total = txtTotal.ToDouble(); WriteRepository repo = new WriteRepository(); if (update) { repo.UpdateHDM(record); } else { repo.InsertHDM(record); currentMonth = 0; } PrepareContractor(); Populate(); }
public Version1(WriteRepository repository) : base(repository) { }
public async Task <TResponse <bool> > UpdateInformationUser(int userId, UpdateInformationModel request, string folder) { try { var user = await GetById(userId); if (user.IsSuccess) { var image = request.Image; string avatar = string.Empty; if (image != null && image.Length > 0) { avatar = $"{user.Data.Username}.png"; } var result = await WriteRepository.ExecuteAsync(SqlQuery.USER_UPDATE_INFORMATION, new { request.FullName, request.DisplayName, request.PhoneNumber, request.Email, request.BranchId, request.Avatar, UserUpdated = userId, DateUpdated = DateTime.Now, Id = userId }); if (result.IsSuccess) { if (result.Data > 0) { if (image != null && image.Length > 0) { try { if (!Directory.Exists(folder)) { Directory.CreateDirectory(folder); } using (FileStream filestream = File.Create(Path.Combine(folder, user.Data.Username) + ".png")) { image.CopyTo(filestream); filestream.Flush(); } } catch (Exception ex) { } } return(await Ok(true)); } return(await Fail <bool>(ErrorEnum.CAN_NOT_CHANGE_USER_INFORMATION.GetStringValue())); } } return(await Fail <bool>(user.Message)); } catch (Exception exception) { return(await Fail <bool>(exception)); } }