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