private void btAddService_Click(object sender, EventArgs e)
{
errorProvider1.Clear();
errorProvider2.Clear();
errorProvider3.Clear();
if (txtNameService.Text == "")
{
errorProvider1.SetError(txtNameService, "not null!");
}
else if (txtKindService.Text == "")
{
errorProvider2.SetError(txtKindService, "not null!");
}
else if (txtCostService.Text == "")
{
errorProvider3.SetError(txtCostService, "not null!");
}
else
{
srvBUS = new ServiceBUS();
ServiceDTO srv = new ServiceDTO();
srv.IDS = txtNameService.Text;
srv.NAME = txtNameService.Text;
srv.KIND = txtKindService.Text;
srv.COST = Decimal.Parse(txtCostService.Text);
bool kq = srvBUS.add(srv);
if (kq == false)
{
MessageBox.Show("Fail!");
}
else
{
MessageBox.Show("Sussces");
}
this.loadData();
}
}
public bool UpdateService(ServiceDTO serviceDTO)
{
try
{
Servicio s1 = context.servicios.Find(serviceDTO.ServicioId);
s1.Cost = serviceDTO.Cost;
s1.Description = serviceDTO.Description;
s1.Name = serviceDTO.Name;
s1.ServiceCategory = context.categories.Where(x => x.CategoryName == serviceDTO.CategoryName).First();
s1.ServiceCategoryId = s1.ServiceCategory.ServiceCategoryId;
context.Update(s1);
context.SaveChanges();
}
catch (System.Exception)
{
return(false);
}
return(true);
}
public void Serialization_SupportsComplexObject()
{
ServiceDTO dto = new ServiceDTO {
Id = Guid.NewGuid(),
Code = "dummy"
};
byte[] serialized = dto.ToByteArray();
serialized
.Should()
.NotBeNullOrEmpty();
var result = serialized.FromByteArray <ServiceDTO>();
result
.Should()
.NotBeNull()
.And
.BeEquivalentTo <ServiceDTO>(dto);
}
public ServiceDTO Build()
{
var serviceDto = new ServiceDTO
{
IsEnabled = true,
Properties = new Dictionary <string, string>()
};
foreach (var room in _rooms.Values)
{
AddRoom(serviceDto, room);
}
if (_confusionResolutionTime.HasValue)
{
serviceDto.Properties.Add(MotionProperties.ConfusionResolutionTime, _confusionResolutionTime.ToString());
}
return(serviceDto);
}
public async Task <LogicResult <ServiceDTO> > GetServiceByID(int ServiceID)
{
var unitofwork = _repositoryHelper.GetUnitOfWork();
var repo = _repositoryHelper.GetRepository <IServiceRepository>(unitofwork);
var result = repo.GetById(ServiceID);
var Result = new ServiceDTO()
{
ID = result.ID,
Image = result.Image,
Name = result.Name,
Star = result.Star.GetValueOrDefault(),
Price = result.Price,
NumOfTimeSlot = result.numOfTimeSlot * 15
};
return(new LogicResult <ServiceDTO>()
{
IsSuccess = true, Result = Result
});
}
private void Notify(ServiceDTO lastServiceDto, IList <ApolloConfigNotification> notifications)
{
if (notifications == null || notifications.Count == 0)
{
return;
}
foreach (ApolloConfigNotification notification in notifications)
{
string namespaceName = notification.NamespaceName;
//create a new list to avoid ConcurrentModificationException
ISet <RemoteConfigRepository> registries = null;
List <RemoteConfigRepository> toBeNotified = new List <RemoteConfigRepository>();
m_longPollNamespaces.TryGetValue(namespaceName, out registries);
ApolloNotificationMessages originalMessages = null;
m_remoteNotificationMessages.TryGetValue(namespaceName, out originalMessages);
ApolloNotificationMessages remoteMessages = originalMessages == null ? null : originalMessages.Clone();
if (registries != null && registries.Count > 0)
{
toBeNotified.AddRange(registries);
}
//since .properties are filtered out by default, so we need to check if there is any listener for it
ISet <RemoteConfigRepository> extraRegistries = null;
m_longPollNamespaces.TryGetValue(string.Format("{0}.{1}", namespaceName, ConfigFileFormat.Properties.GetString()), out extraRegistries);
if (extraRegistries != null && extraRegistries.Count > 0)
{
toBeNotified.AddRange(extraRegistries);
}
foreach (RemoteConfigRepository remoteConfigRepository in toBeNotified)
{
try
{
remoteConfigRepository.OnLongPollNotified(lastServiceDto, remoteMessages);
}
catch (Exception ex)
{
logger.Warn(ex);
}
}
}
}
public void UpdateServiceTest()
{
ServiceDTO sdto3 = new ServiceDTO
{
ServicioId = 2,
Name = "Desarrollo de aplicación web",
Description = "Se realiza la implementación de una aplicación web.",
Cost = 1500,
ServiceCategoryId = 2,
CategoryName = "Developer"
};
mockRepository.Setup(x => x.UpdateService(sdto3))
.Returns(true);
var handler = new UpdateServiceHandler(mockRepository.Object);
UpdateService us = new UpdateService(sdto3);
var res = handler.Handle(us, ct);
Assert.IsTrue(res.Result);
}
public string Disable(ServiceDTO service)
{
if (service == null)
{
return(GenericMessages.ObjectIsNull);
}
string stat;
try
{
_serviceRepository.Update(service);
_unitOfWork.Commit();
stat = string.Empty;
}
catch (Exception exception)
{
stat = exception.Message;
}
return(stat);
}
/// <summary>
/// gets all available services in region
/// </summary>
/// <param name="regionId"></param>
/// <returns></returns>
private List <ServiceDTO> GetAvailableServices(int regionId)
{
List <ServiceDTO> servicesList = new List <ServiceDTO>();
foreach (var service in _services)
{
foreach (var region in service.AvailabilityRegions)
{
if (region.RegionID == regionId)
{
ServiceDTO availableService = new ServiceDTO();
availableService.ServiceID = service.ServiceID;
availableService.ServiceName = service.ServiceName;
servicesList.Add(availableService);
}
}
}
return(servicesList);
}
private void cậpNhậtToolStripMenuItem_Click(object sender, EventArgs e)
{
string nameServiceType = toolStripComboBoxloaiDV.Text;
if (nameServiceType == "")
{
nameServiceType = nameServiceTypeOrigin;
}
var items = ListServiceTypre.Find(p => p.Name.CompareTo(nameServiceType) == 0);
nameService = toolStripTextBoxTenDV.Text;
if (Id == 0)
{
MessageBox.Show("Chọn lại dịch vụ cần update!");
}
if (nameService == "" || price == 0 || nameServiceType == "")
{
MessageBox.Show("Bạn chưa điền đẩy đủ thông tin!");
}
else
{
bool checkPrice = int.TryParse(toolStripTextBoxGiaDV.Text, out price);
if (checkPrice)
{
ServiceDTO service = new ServiceDTO {
ID = Id, IdService = items.ID, Price = price, Name = nameService
};
if (ServiceBLL.Instance.UpdateById(Id, service))
{
MessageBox.Show("Cập nhật thành công!");
ListService = (List <ServiceDTO>)ServiceBLL.Instance.readAll();
LoadService();
}
}
else
{
MessageBox.Show("Không được nhập chữ!");
}
}
}
public async Task <IActionResult> BookService(int serviceID, int regionID, UserDTO user)
{
ServiceDTO service = ValidateserviceRequest(serviceID, regionID);
bool isValidUser = AuthenticateUser(user);
if (service != null && service.AvailabilityRegions.Count > 0 && isValidUser)
{
string serviceid = refernceNumberGenerator();
OrderDTO order = new OrderDTO();
order.Service = new ServiceDTO();
order.UserDetails = new UserDTO();
order.Region = new AvailabilityRegionDTO();
order.Service.ServiceID = service.ServiceID;
order.Service.ServiceName = service.ServiceName;
order.Region = service.AvailabilityRegions.FirstOrDefault();
order.UserDetails = user;
order.ReferenceNumber = serviceid;
order.StatusID = 1;
order.OrderStatus = "Service Requested";
order.IsActive = true;
//Store entry in Temp List
memory.userData.MyOrders.Add(order);
//Call the service bus;
bool send = await SendServiceRequest(order);
string message = "Service " + serviceid + " booked by user " + user.FirstName + ' ' + user.LastName;
if (send)
{
bool res = await SendNotification(message);
}
return(Ok(new { ReferenceNumber = serviceid }));
}
return(BadRequest());
}
public ActionResult EditService(EditServiceViewModel model)
{
if (ModelState.IsValid)
{
if (model.TariffList == null || model.TariffList.Count < 1)
{
ModelState.AddModelError("TariffList", "Добавьте хотя бы один тариф");
return(View(model));
}
ServiceDTO service = new ServiceDTO()
{
Id = Guid.Parse(model.Id),
ServiceName = model.ServiceName,
Properties = model.Properties,
IsInUse = true,
CurrentUsers = 0,
TariffList = new List <TariffDTO>()
};
Guid id;
foreach (var tariff in model.TariffList)
{
var res = Guid.TryParse(tariff.Id, out id);
service.TariffList.Add(new TariffDTO()
{
Id = id,
Service_Id = tariff.Service_Id,
Price = tariff.Price,
TariffName = tariff.TariffName,
TariffProperties = tariff.TariffProperties,
ValidityPeriodTicks = tariff.ValidityPeriod * 864000000000
});
}
_servService.UpdateService(service);
return(RedirectToAction("ServiceIndex"));
}
else
{
return(View(model));
}
}
public async Task InterceptKnownRouteAsync_ReturnsTrueWhenKnownRouteWithAReplyFound()
{
var controller = new RestController(_loggerMock.Object, _anonymousServiceClientMock.Object, _authenticatedServiceClientMock.Object, _cacheMock.Object);
var service = new ServiceDTO {
Code = "dummy",
Name = "dummy",
Id = Guid.NewGuid(),
Address = new Uri("http://address.to"),
UnkownRoutesPassthrough = true,
KnownRoutes = new List <KnownRouteDTO> {
new KnownRouteDTO {
Id = Guid.NewGuid(),
MethodName = "GET",
RelativeUrl = "/path",
Replies = new List <KnownRouteReplyDTO> {
new KnownRouteReplyDTO {
Id = Guid.NewGuid(),
StatusCode = 200,
ContentType = "application/json",
ContentEncoding = "utf-8",
ContentLength = 0
}
}
}
}
};
var type = typeof(BaseActionApiController);
var response = new Mock <HttpResponse>();
var method = type
.GetMethods(BindingFlags.NonPublic | BindingFlags.Instance)
.First(x => x.Name == "InterceptKnownRouteAsync" && x.IsPrivate);
var task = (Task <bool>)method.Invoke(controller, new object[] { null, response.Object, "/path", service });
var result = await task;
result.Should().BeTrue();
}
private void btDeleteService_Click(object sender, EventArgs e)
{
srvBUS = new ServiceBUS();
ServiceDTO srv = new ServiceDTO();
srv.IDS = txtNameService.Text;
srv.NAME = txtNameService.Text;
srv.KIND = txtKindService.Text;
srv.COST = Decimal.Parse(txtCostService.Text);
bool kq = srvBUS.delete(srv);
if (kq == false)
{
MessageBox.Show("Fail!");
}
else
{
MessageBox.Show("Sussces");
}
this.loadData();
}
public async Task <IActionResult> AddService([FromForm] ServiceDTO request)
{
try
{
if (String.IsNullOrEmpty(request.TitleEn))
{
return(StatusCode((int)System.Net.HttpStatusCode.BadRequest, "English Title Not Found!"));
}
else if (String.IsNullOrEmpty(request.TitleAr))
{
return(StatusCode((int)System.Net.HttpStatusCode.BadRequest, "Arabic Title Not Found!"));
}
else if (String.IsNullOrEmpty(request.DescriptionEn))
{
return(StatusCode((int)System.Net.HttpStatusCode.BadRequest, "English Description Not Found!"));
}
else if (String.IsNullOrEmpty(request.DescriptionAr))
{
return(StatusCode((int)System.Net.HttpStatusCode.BadRequest, "Arabic Description Not Found!"));
}
else
{
var result = await _serviceRepo.AddAsync(request);
if (result != null)
{
return(Ok(result));
}
else
{
return(NoContent());
}
}
}
catch (Exception ex)
{
return(StatusCode((int)System.Net.HttpStatusCode.InternalServerError, ex.Message));
}
}
private void btnLuuDichVu_Click(object sender, EventArgs e)
{
ServiceDTO infor = LayThongTinDichVu();
if (btnThemDichVu.Text == "Ngừng")
{
if (ServiceBUS.ThemDichVu(infor))
{
MessageBox.Show("Bạn đã thêm dịch vụ thành công!", "Thông báo", MessageBoxButtons.OK, MessageBoxIcon.Information);
frmQuanLiDichVu_Load(sender, e);
btnCapNhatDichVu.Enabled = true;
btnXoaDichVu.Enabled = true;
gcDanhSachDichVu.Enabled = true;
btnThemDichVu.Text = "Thêm dịch vụ";
}
else
{
MessageBox.Show("Lỗi");
}
}
else if (btnCapNhatDichVu.Text == "Ngừng")
{
infor.MaDichVu = int.Parse(gridView1.GetRowCellValue(gridView1.FocusedRowHandle, gridView1.Columns["MaDichVu"]).ToString());
if (ServiceBUS.SuaThongTinDichVu(infor))
{
MessageBox.Show("Bạn đã sửa thông tin dịch vụ " + txtTenDichVu.Text + " thành công!", "Thông báo", MessageBoxButtons.OK, MessageBoxIcon.Information);
frmQuanLiDichVu_Load(sender, e);
btnThemDichVu.Enabled = true;
btnCapNhatDichVu.Enabled = true;
btnXoaDichVu.Enabled = true;
gcDanhSachDichVu.Enabled = true;
btnCapNhatDichVu.Text = "Cập nhật";
}
else
{
MessageBox.Show("Lỗi");
}
}
}
public void TryDeserialize_ReturnsDeserializedService()
{
HttpClient httpClient = new HttpClient();
HttpClientBase httpClientBase = new HttpClientBase(httpClient, loggerMock.Object);
ServiceDTO dto = new ServiceDTO {
Code = "dummyservice"
};
using (MemoryStream ms = new MemoryStream(System.Text.Encoding.UTF8.GetBytes("{\"Code\":\"dummyservice\"}")))
{
using (StreamReader streamReader = new StreamReader(ms))
{
using (JsonTextReader reader = new JsonTextReader(streamReader))
{
var result = httpClientBase.TryDeserialize <ServiceDTO>(reader, true);
result.Should().BeEquivalentTo(dto);
}
}
}
}
public async Task <ServiceResponse> Update(int id, ServiceDTO updatedService)
{
var service = await _serviceRepository.GetById(id);
if (service == null)
{
throw new KeyNotFoundException();
}
service.Id = updatedService.Id;
service.Name = updatedService.Name;
service.Description = updatedService.Description;
if (service.Name == null)
{
string errorMessage1 = "Service name not found.";
Log.Error(errorMessage1);
return(new ServiceResponse(errorMessage1));
}
if (service.Description == null)
{
string errorMessage2 = "Service description not found.";
Log.Error(errorMessage2);
return(new ServiceResponse(errorMessage2));
}
try
{
_serviceRepository.Update(service);
await _context.SaveChangesAsync();
return(new ServiceResponse());
}
catch (Exception exception)
{
string errorMessage = $"An error occured when updating the item: {exception.Message}";
return(new ServiceResponse(errorMessage));
}
}
public async Task InterceptKnownRouteAsync_ReturnsFalseWhenNoKnownRouteFoundAndCanPassThrough()
{
var controller = new RestController(_loggerMock.Object, _anonymousServiceClientMock.Object, _authenticatedServiceClientMock.Object, _cacheMock.Object);
var service = new ServiceDTO {
Code = "dummy",
Name = "dummy",
Id = Guid.NewGuid(),
Address = new Uri("http://address.to"),
UnkownRoutesPassthrough = true
};
var type = typeof(BaseActionApiController);
var response = new Mock <HttpResponse>();
var method = type
.GetMethods(BindingFlags.NonPublic | BindingFlags.Instance)
.First(x => x.Name == "InterceptKnownRouteAsync" && x.IsPrivate);
var task = (Task <bool>)method.Invoke(controller, new object[] { null, response.Object, "/path", service });
var result = await task;
result.Should().BeFalse();
}
public async Task AddTrainAsync(ServiceDTO services)
{
await CheckEmp(services.EmployeeId);
Cart cart = await _unitOfWork.Carts.GetByAsync(x => x.EmployeeId == services.EmployeeId);
foreach (var item in services.serviceIds)
{
await CheckTrain(item);
Train train = await _unitOfWork.Trains.GetByIdAsynс(item);
train.TravellerId = services.EmployeeId;
Order newOrder = new Order()
{
CartId = cart.Id, ServiceId = item, ServiceTipe = ServiceTipe.Train
};
_unitOfWork.Orders.Create(newOrder);
}
await _unitOfWork.CommitAsync();
}
public void IntercepKnownRouteAsync_ThrowsExceptionForNullParameters()
{
var controller = new RestController(_loggerMock.Object, _anonymousServiceClientMock.Object, _authenticatedServiceClientMock.Object, _cacheMock.Object);
var service = new ServiceDTO();
var type = typeof(BaseActionApiController);
var method = type
.GetMethods(BindingFlags.NonPublic | BindingFlags.Instance)
.First(x => x.Name == "InterceptKnownRouteAsync" && x.IsPrivate);
var task = (Task <bool>)method.Invoke(controller, new object[] { null, null, "/comments", service });
Assert.ThrowsAsync <ArgumentNullException>(async() => await task);
var response = new Mock <HttpResponse>();
task = (Task <bool>)method.Invoke(controller, new object[] { null, response.Object, null, service });
Assert.ThrowsAsync <ArgumentNullException>(async() => await task);
task = (Task <bool>)method.Invoke(controller, new object[] { null, response.Object, "/comments", null });
Assert.ThrowsAsync <ArgumentNullException>(async() => await task);
}
public async Task AddHotelAsync(ServiceDTO services)
{
await CheckEmp(services.EmployeeId);
Cart cart = await _unitOfWork.Carts.GetByAsync(x => x.EmployeeId == services.EmployeeId);
foreach (var item in services.serviceIds)
{
await CheckHotel(item);
Hotel hotel = await _unitOfWork.Hotels.GetByIdAsynс(item);
hotel.TravellerId = services.EmployeeId;
Order newOrder = new Order()
{
CartId = cart.Id, ServiceId = item, ServiceTipe = ServiceTipe.Hotel
};
_unitOfWork.Orders.Create(newOrder);
}
await _unitOfWork.CommitAsync();
}
public async Task AddService(ServiceDTO service, string operatorId)
{
if (!string.IsNullOrEmpty(service?.Station?.StreetAddress))
{
var lonLat = await _amapProxy.Geo(service.Station.StreetAddress);
service.Station.Longitude = lonLat?.Longitude ?? 0;
service.Station.Latitude = lonLat?.Latitude ?? 0;
}
var obj = ServiceFactory.CreateInstance(
service.Title,
service.Introduction,
service.SincerityGold,
service.ServeScope,
service.Category,
service.SubCategory,
service.Station,
service.OrganizationId,
operatorId,
service.ApplicationId);
_serviceRepository.Add(obj);
if (service.Images != null && service.Images.Count() > 0)
{
foreach (var img in service.Images)
{
_serviceImageRepository.Add(new ServiceImage
{
CreatedOn = DateTime.Now,
ImageId = img.ImageId,
ServiceId = obj.Id
});
}
}
_dbUnitOfWork.Commit();
}
public ActionResult AddService(AddServiceViewModel model)
{
if (ModelState.IsValid)
{
if (model.TariffList == null || model.TariffList.Count < 1)
{
ModelState.AddModelError("TariffList", "Добавьте хотя бы один тариф");
return(View(model));
}
ServiceDTO service = new ServiceDTO()
{
ServiceName = model.ServiceName,
Properties = model.Properties,
IsInUse = true,
CurrentUsers = 0,
TariffList = new List <TariffDTO>()
};
foreach (var tariff in model.TariffList)
{
service.TariffList.Add(new TariffDTO()
{
Price = tariff.Price,
TariffName = tariff.TariffName,
TariffProperties = tariff.TariffProperties,
ValidityPeriodTicks = tariff.ValidityPeriod * 864000000000
});
}
_servService.AddService(service);
Logger.Info("New service added successfully");
return(View());
}
else
{
return(View(model));
}
}
public async Task <OperationDetails <int> > UpdateService(ServiceDTO service)
{
OperationDetails <int> operationDetails =
new OperationDetails <int>(false, "", 0);
if (service == null)
{
return(operationDetails);
}
var oldServices = await _uof.ServiceRepository.FindServiceByIdAsync(service.ServicesId);
if (oldServices == null)
{
return(operationDetails);
}
oldServices.Name = service.Name;
oldServices.Description = service.Description;
try
{
oldServices.ServicesId = await _uof.ServiceRepository.UpdateService(oldServices);
await _uof.ServiceActiveTimeRepository.UpdateServiceActiveTimeRange(service.ServiceActiveTimes);
operationDetails = new OperationDetails <int>(true, "", oldServices.ServicesId);
}
catch (Exception ex)
{
operationDetails = new OperationDetails <int>(false, ex.Message, 0);
}
return(operationDetails);
}
public async Task <OperationDetails <ServiceDTO> > GetServiceById(int id)
{
OperationDetails <ServiceDTO> operationDetails =
new OperationDetails <ServiceDTO>(false, "", new ServiceDTO());
if (id <= 0)
{
return(operationDetails);
}
var service = await _uof.ServiceRepository.FindServiceByIdAsync(id);
var serviceDTO = new ServiceDTO
{
ServicesId = service.ServicesId,
Name = service.Name,
Description = service.Description,
ServiceActiveTimes = service.ServiceActiveTimes
};
operationDetails = new OperationDetails <ServiceDTO>(true, "", serviceDTO);
return(operationDetails);
}
public async Task GetOrAddAsync_ReturnsComplexItemFromDelegateIfNotPresentInCache()
{
Mock <IDistributedCache> cacheMock = new Mock <IDistributedCache>();
CancellationTokenSource cts = new CancellationTokenSource(1000);
byte[] emptyBytes = null;
cacheMock.Setup(x =>
x.GetAsync(It.IsAny <string>(), It.IsAny <CancellationToken>())
).ReturnsAsync(emptyBytes);
ServiceDTO dto = new ServiceDTO {
Id = Guid.NewGuid(), Code = "service1"
};
var result = await cacheMock.Object.GetOrAddAsync <ServiceDTO>("dummy", (options) => {
return(Task.FromResult(dto));
}, cts.Token);
result.Should()
.NotBeNull()
.And
.BeEquivalentTo(dto);
}
public async Task <IActionResult> Edit(int id, ServiceDTO serviceDTO)
{
if (id != serviceDTO.Id)
{
_logger.LogError($"Id do not match for Staff.Service.Edit. Expected: {id},Actual {serviceDTO} _post_");
return(RedirectToAction(nameof(Index)));
}
if (ModelState.IsValid)
{
try
{
var result = _mapper.Map <Service>(serviceDTO);
_repositoryWrapper.Service.UpdateService(result);
await _repositoryWrapper.SaveAsync();
}
catch (Exception ex)
{
_logger.LogError($"Error occurred whilst attempting to update Service with id- {id}: {ex}");
}
return(RedirectToAction(nameof(Index)));
}
return(View(nameof(Edit), serviceDTO));
}
public void Save(ServiceDTO serviceDTO)
{
var service = _mapper.Map <DataLayer.Entities.Services>(serviceDTO);
_dataManager.ServicesRepository.Save(service);
}
public async Task <ActionResult <ServiceDTO> > Post([FromBody] ServiceDTO serviceDTO)
{
await _serviseService.UpDateAsync(serviceDTO);
return(Ok(serviceDTO));
}
