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