public void AddClient()
{
ClientModel model = new ClientModel()
{
_firstName = "TestName",
_lastName = "TestLastName"
};
Assert.IsTrue(service.AddClient(model));
}
public ActionResult ClientAdd(ClientVM model)
{
// JsonModel jmodel = new jsonModel();
Client client;
if (ModelState.IsValid)
{
try
{
client = new Client();
client.Name = model.Client.Name;
client.Surname = model.Client.Surname;
client.TcKimlik = model.Client.TcKimlik;
client.Problem = model.Client.Problem;
client.BirthDate = model.Client.BirthDate;
client.Note = model.Client.Note;
client.Continuity = true;
client.CompanyID = Convert.ToInt32(AccountController._compID); ;
_clientService.AddClient(client);
_contactService.AddContact(new Contact { ClientID = client.ClientID, Address = model.Contact.Address, PhoneNumber1 = model.Contact.PhoneNumber1, PhoneNumber2 = model.Contact.PhoneNumber2, IsActive = true, Email = model.Contact.Email });
ViewBag.Message = "Danışan Başarıyla Eklendi";
}
catch (Exception)
{
throw;
}
}
return View();
}
/// <summary>
/// Add a new client
/// </summary>
/// <param name="oHostSecurityToken">HostSecurityToken obtained when security provider of IWS is called</param>
/// <param name="client">client details</param>
/// <param name="person">Person details</param>
/// <param name="organisation">Organisation details</param>
/// <param name="addresses">Addresses</param>
/// <param name="addressInformation"></param>
/// <returns></returns>
public ClientReturnValue AddClient(HostSecurityToken oHostSecurityToken, Client client,
Person person,
Organisation organisation,
List <Address> addresses,
List <AdditionalAddressElement> addressInformation)
{
ClientReturnValue returnValue = null;
try
{
if (Functions.ValidateIWSToken(oHostSecurityToken))
{
oClientService = new ClientService();
returnValue = oClientService.AddClient(Functions.GetLogonIdFromToken(oHostSecurityToken), client, person, organisation, addresses, addressInformation);
}
else
{
returnValue = new ClientReturnValue();
returnValue.Success = false;
returnValue.Message = "Invalid Token";
}
}
catch (Exception ex)
{
returnValue = new ClientReturnValue();
returnValue.Success = false;
returnValue.Message = ex.Message;
}
return(returnValue);
}
static void Main(string[] args)
{
using (var context = new AppDbContext())
{
ClientService clientService = new ClientService(context);
RoomService roomService = new RoomService(context);
SettlementService settlementService = new SettlementService(context);
clientService.AddClient("abc", "def", 123, "jerk");
roomService.AddRoom(123, 1, 2, 123);
settlementService.AddSettlement(23, 25, 1, 1);
Client client = context.Clients
.OrderBy(b => b.Name)
.First();
Room room = context.Rooms
.OrderBy(b => b.PersonNumber)
.First();
Settlement settlements = context.Settlements
.OrderBy(b => b.SettingDate)
.First();
Console.WriteLine(client.Name);
context.Remove(client);
context.Remove(room);
context.Remove(settlements);
context.SaveChanges();
}
}
private async Task OnSave()
{
OnClose?.Invoke();
ResultModel <string> result = new ResultModel <string>();
if (ClientEditDto.Id == null)
{
result = await ClientService.AddClient(ClientEditDto);
}
else
{
result = await ClientService.EditClient(ClientEditDto);
}
if (result.status.code == ResultCode.Success)
{
await ToastService.Show(new ToastOption()
{
Title = "保存成功",
Content = "保存成功，4 秒后自动关闭"
});
}
else
{
await ToastService.Show(new ToastOption()
{
Title = "保存失败",
Content = $"保存失败，{result.status.text}",
Category = ToastCategory.Error
});
}
await Task.CompletedTask;
}
public void AddClient_AddNullInsteadClient_ThrowsArgumentNullException()
{
ClientService clientService = new ClientService(_clientDAL);
Assert.ThrowsException <ArgumentNullException>(() => clientService.AddClient(null));
_clientDAL.DidNotReceive().AddClient(Arg.Any <IClient>());
}
public void AddClient_AddClientWithInvalidFields_ThrowsException()
{
ClientService clientService = new ClientService(_clientDAL);
Assert.ThrowsException <ArgumentException>(() => clientService.AddClient(new Client(Guid.NewGuid(), null)));
_clientDAL.DidNotReceive().AddClient(Arg.Any <IClient>());
}
public async Task AddClient_should_call_AddClient_on_repository()
{
var ClientRepositoryMock = new Mock <IClientRepository>();
var CarRepositoryMock = new Mock <ICarRepository>();
var MapperMock = new Mock <IMapper>();
MapperMock.Setup(x => x.Map <ClientDTO, Client>(It.IsAny <ClientDTO>()))
.Returns(new Client());
var client = new ClientDTO
{
EmailAddress = "*****@*****.**",
UserRole = "Client",
FirstName = "xxx",
LastName = "yyy",
IdentityCardNumber = "testNumber",
Pesel = "testPesel",
Cars = new List <CarDTO>()
};
var ClientService = new ClientService(ClientRepositoryMock.Object, MapperMock.Object, CarRepositoryMock.Object);
await ClientService.AddClient(client);
MapperMock.Verify(x => x.Map <ClientDTO, Client>(It.IsAny <ClientDTO>()), Times.Once);
ClientRepositoryMock.Verify(x => x.AddClient(It.IsAny <Client>()), Times.Once);
}
public JsonResult Post(string dataJson)
{
string msg = string.Empty;
bool state = true;
try
{
var client = Serializer.ToObject <Client>(dataJson);
ClientService dbService = new ClientService();
client.Id = dbService.AddClient(client);
ISubscriber redisPublic = redis.GetSubscriber();
if (redis.IsConnected)
{
using (var memoryStream = new MemoryStream())
{
ProtoBuf.Serializer.Serialize <Client>(memoryStream, client);
redisPublic.Publish(client.DeviceName.Trim(), memoryStream.ToArray());
}
}
return(new JsonResult {
Data = new { state = state, msg = msg }
});
}
catch (Exception e)
{
return(new JsonResult {
Data = new { state = state, msg = e.Message }
});
}
}
public IActionResult Add(ClientInputModel input)
{
if (!ModelState.IsValid)
{
return(View(input));
}
var client = _mapper.Map <Client>(input);
client.SetClientType(input.ClientType);
if (input.ClientType != ClientType.Noninteractive)
{
client.AllowedScopes = new List <ClientScope>
{
new ClientScope
{
Scope = IdentityServerConstants.StandardScopes.OpenId
},
new ClientScope
{
Scope = IdentityServerConstants.StandardScopes.Profile
},
new ClientScope
{
Scope = IdentityServerConstants.StandardScopes.Email
}
};
}
_clientService.AddClient(client);
_clientService.SaveChanges();
_logger.LogInformation("{user} created client {client}", User.Identity.Name, client.ClientId);
return(Redirect($"Edit/{client.Id}#scopes"));
}
private async Task <dynamic> AddClient()
{
this.RequiresClaims(AuthorizationManageClientsClaim, AuthorizationWriteClaim);
var clientApiModel = this.Bind <ClientApiModel>(model => model.CreatedBy,
model => model.CreatedDateTimeUtc,
model => model.ModifiedBy,
model => model.ModifiedDateTimeUtc,
model => model.TopLevelSecurableItem);
var incomingClient = clientApiModel.ToClientDomainModel();
Validate(incomingClient);
try
{
var client = await _clientService.AddClient(incomingClient);
await AddDefaultRoleAndPermissionAsync(client);
return(CreateSuccessfulPostResponse(client.ToClientApiModel()));
}
catch (AlreadyExistsException <Permission> ex)
{
return(CreateFailureResponse(ex.Message, HttpStatusCode.BadRequest));
}
catch (IncompatiblePermissionException ex)
{
return(CreateFailureResponse(ex.Message, HttpStatusCode.BadRequest));
}
}
public async Task <ActionResult> AddClient([FromBody] ClientDTO clientDTO)
{
if (ModelState.IsValid)
{
var client = mapper.Map <Client>(clientDTO);
await clientService.AddClient(client);
}
return(Ok("Has been Added"));
}
public JsonResult AddClient(Client client)
{
int cmd = -1;
cmd = _clientService.AddClient(client);
string result = (cmd > 0) ? "Added" : "Add Failed";
return(new JsonResult(result));
}
public object Subscribe(string channel)
{
var ip = GetClientIP();
var clientId = clientService.AddClient(ip);
clientService.AddSubscriber(clientId, channel);
broker.Subscribe(channel, clientId);
return(Ok(clientId));
}
public void AddClient_AddNewClient_ReturnsTrue()
{
// Arrange
ClientService clientService = new ClientService(_clientDAL);
Client clientToAdd = new Client(Guid.NewGuid(), "Max", null, "Addr", "CITY", null);
// Act
clientService.AddClient(clientToAdd);
// Assert
_clientDAL.Received(1).AddClient(Arg.Is <IClient>(client => client.Name == "Max"));
}
public string Get()
{
var client = clientService.AddClient(new Client() { FirstName = "Dan", LastName = "Brezoi", MiddleName = "Alexandru" });
var allClients = clientService.GetAllClients();
var firstClient = clientService.GetClient(client.ClientId);
var storeProcedureResult = clientService.GetClientsWithFirstName("Dan");
clientService.Add10Clients();
//clientService.AddClient(FirstName: "Oscar", LastName: "Lazlo");
return string.Empty;
}
public void ThrowArgumentNullException_WhenInvokedWithInvalidParameter()
{
//Arrange
var dbContextMock = new Mock <ISportscardSystemDbContext>();
var mapperMock = new Mock <IMapper>();
ClientDto clientDto = null;
var clientService = new ClientService(dbContextMock.Object, mapperMock.Object);
//Act && Assert
Assert.ThrowsException <ArgumentNullException>(() => clientService.AddClient(clientDto));
}
public void DbserviceAddClientsTest()
{
Assert.AreEqual(0, service.GetClientsNumber());
service.AddClient(4, "Mateusz", "Owczarek", 22);
service.AddClient(5, "Maciej", "Kopa", 16);
service.AddClient(6, "Monika", "Roksa", 23);
Assert.AreEqual(3, service.GetClientsNumber());
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = Input.Name + "_" + Input.Surname, Email = Input.Email
};
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
var client = _clientService.CreateClient(Guid.Parse(user.Id), Input.Email, Input.Name, Input.Surname, Input.PhoneNumber, Input.Address);
_clientService.AddClient(client);
_clientService.Save();
_logger.LogInformation("User created a new account with password.");
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { area = "Identity", userId = user.Id, code = code, returnUrl = returnUrl },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
if (_userManager.Options.SignIn.RequireConfirmedAccount)
{
return(RedirectToPage("RegisterConfirmation", new { email = Input.Email, returnUrl = returnUrl }));
}
else
{
await _signInManager.SignInAsync(user, isPersistent : false);
return(LocalRedirect(returnUrl));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
public ActionResult Register(string FirstName, string LastName, string DateOfBirht, string Address, string Phone, string Email)
{
var client = new Client()
{
FirstName = FirstName, LastName = LastName, DateOfBirth = DateOfBirht, Phone = Phone, Address = Address, Email = Email
};
ClientService.AddClient(client);
var listClients = new List <Client>();
listClients.Add(client);
ViewBag.clients = listClients;
return(PartialView("_Registration"));
}
public async Task <IHttpActionResult> Post(ClientEntity client)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
ClientRegistrationInfo clientInfo = new ClientRegistrationInfo()
{
FirstName = client.ClientFirstName, LastName = client.ClientLastName, PhoneNumber = client.PhoneNumber
};
clientService.AddClient(clientInfo);
return(Created(client));
}
public void AddClientToDabatase_WhenInvokedWithValidParameters()
{
//Arrange
var dbContextMock = new Mock <ISportscardSystemDbContext>();
var mapperMock = new Mock <IMapper>();
var expectedClient = new Client()
{
FirstName = "Stamat", LastName = "Stamatov", Age = 25
};
var data = new List <Client>
{
new Client {
FirstName = "Stamat", LastName = "Stamateev", Age = 26
},
new Client {
FirstName = "Stamat", LastName = "Stamatev", Age = 27
},
new Client {
FirstName = "Stamat", LastName = "Stamatav", Age = 28
}
};
var mockSet = new Mock <DbSet <Client> >();
mockSet.SetupData(data);
mockSet.Setup(m => m.Add(It.IsAny <Client>()));
dbContextMock
.Setup(x => x.Clients)
.Returns(mockSet.Object);
var clientDto = new ClientDto()
{
FirstName = "Stamat", LastName = "Stamatov", Age = 25
};
mapperMock
.Setup(x => x.Map <Client>(clientDto))
.Returns(expectedClient);
var clientService = new ClientService(dbContextMock.Object, mapperMock.Object);
//Act
clientService.AddClient(clientDto);
//Assert
mockSet.Verify(x => x.Add(expectedClient), Times.Once);
}
static void addClient()
{
Paymill.ApiKey = Properties.Settings.Default.ApiKey;
Paymill.ApiUrl = Properties.Settings.Default.ApiUrl;
ClientService clientService = Paymill.GetService <ClientService>();
Client c = new Client();
c.Description = "Prueba API";
c.Email = "*****@*****.**";
Client newClient = clientService.AddClient(c);
Console.WriteLine("ClientID:" + newClient.Id);
Console.Read();
}
public ActionResult AddEdit(ClientModel model)
{
//model.AddedBy = HttpContext.Session.GetString("UserName");
bool ClientStatus = ClientService.AddClient(model);
if (ClientStatus)
{
TempData["Success"] = "Client Added Successfully.";
}
else
{
TempData["Error"] = "Error, Please Try Again.";
}
return(RedirectToAction("Index"));
}
protected void btnSave_Click(object sender, EventArgs e)
{
Client client = new Client()
{
ClientSSN = SSN.Text,
ClientFirstName = ClientFirstName.Text,
ClientMiddleName = ClientMiddleName.Text,
ClientLastName = ClientLastName.Text,
Active = Active.Checked?true:false,
DateAdded = DateTime.Now,
RepresentativeID = ddlRepresentative.SelectedValue.ToInt()
};
ClientService.AddClient(client);
Response.Redirect("SearchClient.aspx");
}
public JsonResult Create([Bind(Include = "Name")] Models.ClientCreateView client)
{
if (ModelState.IsValid)
{
var clientForSave = Mapper.Map <Client>(client);
try
{
clientService.AddClient(clientForSave);
return(Json(new { result = true }));
}
catch (Exception e)
{
return(Json(new { result = false, message = "Server error, when try add client" }));
}
}
return(Json(new { result = false, message = "Invalid model" }));
}
//[TestSource]
//[TestCaseSource]
public async Task Can_Add_Client()
{
//arrange
var mock = new Mock <IRepository <Client> >();
var clientService = new ClientService(mock.Object);
var client = new Client {
Name = "Test"
};
// act
await clientService.AddClient(client);
// assert
// mock.Verify(c => c.AddAsync(It.IsAny<Client>()), Times.Once());
mock.Verify(c => c.AddAsync(It.Is <Client>(s => s.Name == "Test")), Times.Once());
// Assert.AreEqual("Test", client.Name);
// Assert.IsTrue(client.DateTimeRegister != default(DateTime));
}
//Add a new client
public EditClientViewModel()
{
WindowName = "Ajout d'un client";
IsAddClientVisible = true;
IsValidateChangesVisible = false;
NewClient = new Client();
Passkey = ClientService.GenerateNewPasskey();
BDEs = new List <BDE>(BDEService.GetBDEs());
SelectedBde = BDEs.FirstOrDefault();
Quit = new RelayCommand(() => Close(), o => true);
GenerateNewPasskey = new RelayCommand(() =>
{
Passkey = ClientService.GenerateNewPasskey();
}, o => true);
AddClient = new RelayCommand(() =>
{
if (string.IsNullOrWhiteSpace(Name) || string.IsNullOrWhiteSpace(BadgeID) || string.IsNullOrWhiteSpace(BadgeID) || BadgeID.Length > 15 ||
SelectedBde == null || double.IsNaN(Balance) || Balance < 0.00)
{
FormNotValid();
return;
}
NewClient.IdBDE = SelectedBde.idBDE;
ClientService.AddClient(NewClient);
var dialogService = new DialogService();
dialogService.ShowInformationWindow("Le compte client a correctement été ajouté !", "Ajout effectué",
MessageBoxButton.OK, MessageBoxImage.Information);
Close();
}, o => true);
}
public Response GetResponse(HttpListenerRequest request, string[] parameters)
{
try
{
switch (request.HttpMethod)
{
case "GET":
var clients = _clientService.GetClients();
var clientViewModels = clients.Select(ClientViewModel.ConvertToViewModel).ToList();
return(new Response(200,
JsonConvert.SerializeObject(clientViewModels, new JsonApiSerializerSettings())));
case "POST":
var body = new StreamReader(request.InputStream).ReadToEnd();
var clientViewModel = JsonConvert.DeserializeObject <ClientViewModel>(body);
var id = _clientService.AddClient(Client.ConvertToClient(clientViewModel));
var idVm = new IdViewModel {
Id = id
};
return(new Response(201, JsonConvert.SerializeObject(idVm, new JsonApiSerializerSettings())));
}
return(BasicResponseBuilder.GetBadRequest());
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return(new Response(400, "todo"));
}
}
private async Task <dynamic> AddClient()
{
this.RequiresClaims(AuthorizationManageClientsClaim, AuthorizationWriteClaim);
var clientApiModel = this.Bind <ClientApiModel>(model => model.CreatedBy,
model => model.CreatedDateTimeUtc,
model => model.ModifiedBy,
model => model.ModifiedDateTimeUtc,
model => model.TopLevelSecurableItem);
var incomingClient = clientApiModel.ToClientDomainModel();
Validate(incomingClient);
try
{
Client client = await _clientService.AddClient(incomingClient);
return(CreateSuccessfulPostResponse(client.ToClientApiModel()));
}
catch (AlreadyExistsException <Client> ex)
{
Logger.Error(ex, ex.Message, incomingClient.Id);
return(CreateFailureResponse($"The specified client with id: {incomingClient.Id} already exists.",
HttpStatusCode.BadRequest));
}
}
