public async Task <Tuple <SiteDto, UnitDto> > SiteCreate(string name)
{
log.LogEverything("Communicator.SiteCreate", "called");
log.LogVariable("Communicator.SiteCreate", nameof(name), name);
string response = await http.SiteCreate(name);
var parsedData = JRaw.Parse(response);
int unitId = int.Parse(parsedData["unit_id"].ToString());
int otpCode = int.Parse(parsedData["otp_code"].ToString());
SiteDto siteDto = new SiteDto(int.Parse(parsedData["id"].ToString()), parsedData["name"].ToString(), "", "", 0, 0, unitId, 0); // WorkerUid is set to 0, because it's used in this context.
UnitDto unitDto = new UnitDto()
{
UnitUId = unitId,
CustomerNo = 0,
OtpCode = otpCode,
SiteUId = siteDto.SiteId,
CreatedAt = DateTime.Parse(parsedData["created_at"].ToString()),
UpdatedAt = DateTime.Parse(parsedData["updated_at"].ToString()),
WorkflowState = Constants.WorkflowStates.Created
};
Tuple <SiteDto, UnitDto> result = new Tuple <SiteDto, UnitDto>(siteDto, unitDto);
return(result);
}
private static void SetTitle(ExcelWorksheet worksheet, UnitDto unit, DateTimeOffset dueDate)
{
var company = "PT DAN LIRIS";
var title = "LAPORAN BUDGET CASH FLOW";
var unitName = "UNIT: ";
if (unit != null)
{
unitName += unit.Name;
}
var cultureInfo = new CultureInfo("id-ID");
var date = $"PERIODE {dueDate.AddMonths(1).DateTime.ToString("MMMM yyyy", cultureInfo)}";
worksheet.Cells["A1"].Value = company;
worksheet.Cells["A1:H1"].Merge = true;
worksheet.Cells["A1:H1"].Style.Font.Size = 20;
worksheet.Cells["A1:H1"].Style.Font.Bold = true;
worksheet.Cells["A2"].Value = title;
worksheet.Cells["A2:H2"].Merge = true;
worksheet.Cells["A2:H2"].Style.Font.Size = 20;
worksheet.Cells["A2:H2"].Style.Font.Bold = true;
worksheet.Cells["A3"].Value = unitName;
worksheet.Cells["A3:H3"].Merge = true;
worksheet.Cells["A3:H3"].Style.Font.Size = 20;
worksheet.Cells["A3:H3"].Style.Font.Bold = true;
worksheet.Cells["A4"].Value = date;
worksheet.Cells["A4:H4"].Merge = true;
worksheet.Cells["A4:H4"].Style.Font.Size = 20;
worksheet.Cells["A4:H4"].Style.Font.Bold = true;
}
public async Task <IActionResult> UpdateUnit([FromRoute] int id, [FromBody] UnitDto entityDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != entityDto.Id)
{
return(BadRequest());
}
var entity = await _repository.GetByIdAsync(entityDto.Id);
if (entity == null)
{
return(NotFound("Unit does not exist"));
}
_mapper.Map(entityDto, entity);
try
{
_repository.Update(entity);
await _unitOfWork.SaveAsync();
}
catch (Exception)
{
throw new Exception("An unexpected error occured. Could not update.");
}
return(Ok(_mapper.Map <UnitDto>(entity)));
}
public virtual ActionResult SaveUnit(UnitDto dto)
{
bool isSuccess = true;
string unit = string.Empty, alertMessage = string.Empty;
if (ModelState.IsValid)
{
if (!_iUnitService.SaveUnit(dto))
{
isSuccess = false;
Danger(Messages.ErrorOccuredDuringProcessing);
}
else
{
Success(Messages.InsertSuccess);
unit = this.RenderRazorViewToString(IOBALANCEMVC.AdminManagement.Unit.Views._ListUnit, GetUnit());
}
}
else
{
isSuccess = false;
Danger(Messages.ErrorOccuredDuringProcessing);
}
alertMessage = this.RenderRazorViewToString(IOBALANCEMVC.Shared.Views._Alerts, string.Empty);
var jsonResult = new
{
isSuccess = isSuccess,
alertMessage = alertMessage,
unit = unit
};
return(Json(jsonResult, JsonRequestBehavior.AllowGet));
}
public virtual ActionResult UpdateUnit(UnitDto dto)
{
bool isSuccess = true;
string unit = string.Empty, alertMessage = string.Empty;
var oldUnit = _iUnitService.FindUnitById(dto.UnitID);
dto.UnitID = oldUnit.UnitID;
if (!_iUnitService.UpdateUnitDetails(dto))
{
isSuccess = false;
Danger(Messages.ErrorOccuredDuringProcessing);
}
else
{
Success(Messages.UpdateSuccess);
unit = this.RenderRazorViewToString(IOBALANCEMVC.AdminManagement.Unit.Views._ListUnit, GetUnit());
}
alertMessage = this.RenderRazorViewToString(IOBALANCEMVC.Shared.Views._Alerts, string.Empty);
var jsonResult = new
{
isSuccess = isSuccess,
alertMessage = alertMessage,
unit = unit
};
return(Json(jsonResult, JsonRequestBehavior.AllowGet));
}
public async Task <ValidationResultModel> ValidateAsync(Guid orgId, UnitDto model)
{
// Reset validation errors
model.Errors.Clear();
#region Formatting: Cleansing and formatting
model.Code = model.Code.ToUpper();
model.Name = model.Name.TrimExtraSpaces();
model.Description = model.Description.TrimExtraSpaces();
#endregion
#region Validation: Duplicate
// Check code duplicate
var duplCode = new Duplicate {
Field = DuplicateField.Code, Value = model.Code, Id = model.Id, ParentId = orgId
};
if (await ExistsAsync(duplCode))
{
model.Errors.AddError(nameof(model.Code), $"{nameof(model.Code)} '{model.Code}' already exists");
}
// Check name duplicate
var duplName = new Duplicate {
Field = DuplicateField.Name, Value = model.Name, Id = model.Id, ParentId = orgId
};
if (await ExistsAsync(duplName))
{
model.Errors.AddError(nameof(model.Name), $"{nameof(model.Name)} '{model.Name}' already exists");
}
#endregion
return(model.Errors);
}
public async Task <IActionResult> Put(UnitDto unitDto, int id)
{
try
{
if (id == 0)
{
return(BadRequest("Id cannot be 0"));
}
Unit temp = new Unit(unitDto);
bool hasOverwritten = await _putService.PutAsync(temp, id);
IEnumerable <Unit> result = await _getService.GetAsync(id);
if (hasOverwritten)
{
return(Ok(result.FirstOrDefault()));
}
return(CreatedAtAction(
nameof(Put),
id,
result.FirstOrDefault()));
}
catch (Exception exception)
{
_exceptionLogger.LogException(exception, nameof(UnitsController), _logger);
throw;
}
}
public bool Delete(UnitDto unit)
{
var result = false;
try
{
var delete = _unitOfWork.UnitRepository.Find(u => u.Code == unit.Code);
if (delete.Any())
{
_unitOfWork.UnitRepository.Remove(delete.First());
_unitOfWork.Save();
result = true;
return(result);
}
return(result);
}
catch (Exception)
{
throw;
}
}
public UnitItemDto(double total, double nominal, double currencyNominal, DivisionDto division, UnitDto unit)
{
Total = total;
Nominal = nominal;
CurrencyNominal = currencyNominal;
Division = division;
Unit = unit;
}
private Unit ConvertUnitDtoToUnit(UnitDto unitDto)
{
var config = new AutoMapper.MapperConfiguration(cfg => cfg.CreateMap <UnitDto, Unit>());
var mapper = config.CreateMapper();
var unit = mapper.Map <Unit>(unitDto);
return(unit);
}
public async Task <PopularResult <string> > UpdateAsync(UnitDto dto)
{
var result = new PopularResult <string>();
var unit = ObjectMapper.Map <UnitDto, UnitEntity>(dto);
await _unitRepository.UpdateAsync(unit);
result.Success("更新成功");
return(result);
}
public async Task <string> Update(UnitDto dto)
{
if (!menu.ModifyAccess)
{
return(null);
}
return(await _unitService.Update(dto));
}
public string Insert(UnitDto dto)
{
if (!menu.WriteAccess)
{
return(null);
}
return(_unitService.Insert(dto));
}
private void btnSaveUnit_Click(object sender, EventArgs e)
{
UnitDto unitdto = new UnitDto();
unitdto.posunitname = txtUnitName.Text;
unitdto.posunit = txtUnit.Text;
string message = unitRepo.SaveUnit(unitdto);
this.ShowMessageSucsess(message);
}
public bool SaveUnit(UnitDto unitDetails)
{
this.unit = unitDetails.DtoToEntity();
if (this._unit.Insert(this.unit).IsNull())
{
return(false);
}
return(true);
}
public IActionResult Delete(UnitDto input)
{
if (ModelState.IsValid && _unitService.Delete(input))
{
return(Ok());
}
else
{
return(BadRequest());
}
}
public ActionResult AddUnit()
{
if (!menu.WriteAccess)
{
return(RedirectToAction("Logout", "Account"));
}
var obj = new UnitDto();
return(View("AddModifyUnit", obj));
}
private static void AssertCreateFails(UnitGroup group, UnitDto dto)
{
try
{
Unit.Create(dto, group);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsNotInstanceOfType(e, typeof (AssertFailedException));
}
}
private static void AssertCreateFails(UnitGroup group, UnitDto dto)
{
try
{
Unit.Create(dto, group);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsNotInstanceOfType(e, typeof(AssertFailedException));
}
}
public async Task <ActionResult <UnitDto> > Create(UnitDto unitDto)
{
var unit = _mapper.Map <Unit>(unitDto);
var validationRes = _validator.Validate(unit);
if (!validationRes.IsValid)
{
return(BadRequest(new { errors = validationRes.Errors }));
}
var res = await _unitRepository.Create(unit);
return(CreatedAtAction(nameof(Get), new { Id = unit.Id }, unit));
}
public async Task <ActionResult> Put(int id, [FromBody] UnitDto unitDto)
{
var unitUpdate = await _unitRepository.Get(id);
if (unitUpdate == null)
{
return(NotFound());
}
_mapper.Map(unitDto, unitUpdate);
await _unitRepository.Update(id, unitUpdate);
return(NoContent());
}
public void Arrange()
{
var mapper = Substitute.For <IUnitMapper>();
var repository = Substitute.For <IUnitsRepository>();
unit = new Unit();
repository.GetUnitByName(UnitName).Returns(this.unit);
this.unitDto = new UnitDto();
mapper.Map(this.unit).Returns(this.unitDto);
director = new GetUnitsDirector(mapper, repository);
}
public ActionResult SaveUnit(UnitDto dto)
{
if (String.IsNullOrWhiteSpace(dto.Name))
{
return(this.Direct(new { success = false }));
}
if (dto.Id == Guid.Empty.ToString())
{
dto.Id = new Guid().ToString();
}
return(this.Direct(new { success = true, data = dto }));
}
public static IOBalanceEntity.Unit DtoToEntity(this UnitDto dto)
{
IOBalanceEntity.Unit entity = null;
if (!dto.IsNull())
{
entity = new IOBalanceEntity.Unit()
{
UnitDesc = dto.UnitDesc
};
}
return(entity);
}
public async Task <PopularResult <string> > InsertAsync(UnitDto dto)
{
var result = new PopularResult <string>();
var entity = ObjectMapper.Map <UnitDto, UnitEntity>(dto);
var unit = await _unitRepository.InsertAsync(entity);
if (unit == null)
{
result.Failed("添加失败");
return(result);
}
result.Success("添加成功");
return(result);
}
public static Unit Create(UnitDto dto, UnitGroup group)
{
var unit = new Unit
{
Abbreviation = dto.Abbreviation,
IsReference = dto.IsReference,
Name = dto.Name,
Multiplier = dto.Multiplier
};
unit.SetUnitGroup(group);
Validate(unit);
return(unit);
}
public async Task <bool> Update(UnitDto obj)
{
Department value = Mapper.Map <Department>(obj);
try
{
db.Entry(value).State = EntityState.Modified;
await db.SaveChangesAsync();
return(true);
}
catch { return(false); }
}
private static UnitDto GetUnitDto(ProductSubstanceDto dto)
{
var unitDto = new UnitDto
{
Abbreviation = dto.UnitAbbreviation,
AllowConversion = dto.UnitGroupAllowConversion,
Divisor = dto.UnitDivisor,
IsReference = dto.UnitIsReference,
Multiplier = dto.UnitMultiplier,
Name = dto.UnitName,
UnitGroupName = dto.UnitGroupName
};
return(unitDto);
}
private UnitDto GetUnitDto()
{
var unitDto = new UnitDto
{
Abbreviation = Dto.UnitAbbreviation,
AllowConversion = Dto.UnitGroupAllowConversion,
Divisor = Dto.UnitDivisor,
IsReference = Dto.UnitIsReference,
Multiplier = Dto.UnitMultiplier,
Name = Dto.UnitName,
UnitGroupName = Dto.UnitGroupName
};
return(unitDto);
}
public void Arrange()
{
var mapper = Substitute.For <IUnitMapper>();
var repository = Substitute.For <IUnitsRepository>();
var units = new List <Unit> {
new Unit(), new Unit()
};
repository.GetAllUnitsWithPeople().Returns(units);
unitDtoOne = new UnitDto();
unitDtoTwo = new UnitDto();
mapper.Map(units.First()).Returns(this.unitDtoOne);
mapper.Map(units.Skip(1).First()).Returns(this.unitDtoTwo);
director = new GetUnitsDirector(mapper, repository);
}
public string Insert(UnitDto dto)
{
string message = "";
try
{
int result = _unitRepository.Insert(dto.ToEntity());
message = _messageClass.ShowSuccessMessage(result);
}
catch (SqlException ex)
{
message = _messageClass.ShowErrorMessage(string.Format("{0} ~ {1}", ex.Number.ToString(), ex.Message));
}
return(message);
}
public ActionResult SaveUnit(UnitDto dto)
{
if (String.IsNullOrWhiteSpace(dto.Name))
return this.Direct(new { success = false });
if (dto.Id == Guid.Empty.ToString()) dto.Id = new Guid().ToString();
return this.Direct(new { success = true, data = dto });
}
