/// <summary>
/// Назначить сделке указанный договор с клиентом.
/// </summary>
/// <param name="deal">Сделка.</param>
/// <param name="contract">Договор с клиентом.</param>
/// <param name="user">Пользователь, выполняющий операцию.</param>
public void SetContract(Deal deal, ClientContract contract, User user)
{
if (deal.Contract == null)
{
CheckPossibilityToAddContract(deal, user);
}
else
{
CheckPossibilityToChangeContract(deal, user);
}
if (deal.Contract != contract)
{
CheckForMaxCashPaymentSumExceeding(deal, contract);
var oldContract = deal.Contract;
deal.Contract = contract;
dealRepository.Save(deal);
if (oldContract != null)
{
if (clientContractRepository.IsUsedBySingleDeal(oldContract, deal)) //коммита еще не было, поэтому в БД у сделки еще старый договор
{
clientContractRepository.Delete(oldContract);
}
}
}
}
public void DealServiceTest_ChangeContractAndOldContractIsUsedByAnyDeal_OldContractStaysUndeleted()
{
//Arrange
var client = new Mock <Client>();
client.Setup(x => x.Organizations).Returns(new List <ContractorOrganization> {
clientOrganization
});
var oldContract = new ClientContract(accountOrganization, clientOrganization, "Старый договор", "1", DateTime.Now, DateTime.Now);
var newContract = new ClientContract(accountOrganization, clientOrganization, "Новый договор", "2", DateTime.Now, DateTime.Now);
var deal = new Deal_Accessor("Сделка1", It.IsAny <User>())
{
Client = client.Object, Contract = oldContract
};
clientContractRepository.Setup(x => x.IsUsedBySingleDeal(It.IsAny <ClientContract>(), It.IsAny <Deal>())).Returns(false);
//Act
dealService.SetContract((Deal)deal.Target, newContract, user.Object);
//Assert
clientContractRepository.Verify(x => x.Delete(It.IsAny <ClientContract>()), Times.Never());
}
private bool IsPermissionToPerformOperation(ClientContract clientContract, User user, Permission permission)
{
bool result = false;
var distribution = user.GetPermissionDistributionType(permission);
switch (distribution)
{
case PermissionDistributionType.None:
result = false;
break;
case PermissionDistributionType.Personal:
case PermissionDistributionType.Teams:
var deals = user.Teams.SelectMany(x => x.Deals).Intersect(clientContractRepository.GetDeals(clientContract));
result = distribution == PermissionDistributionType.Personal ? deals.Any(x => x.Curator == user) : deals.Any();
break;
case PermissionDistributionType.All:
result = true;
break;
}
return(result);
}
private void CheckPermissionToPerformOperation(ClientContract clientContract, User user, Permission permission)
{
if (!IsPermissionToPerformOperation(clientContract, user, permission))
{
throw new Exception(String.Format("Недостаточно прав для выполнения операции «{0}».", permission.GetDisplayName()));
}
}
/// <summary>
/// Delete Employee
/// </summary>
/// <returns></returns>
public static ResponseStatus Delete(
HeaderInfo headerInfo,
ClientContract clientContract)
{
var ret = new ResponseStatus();
ret.Message = "Employee Deleted successfully";
if (clientContract.ExternalID == null)
{
clientContract.ExternalID = "";
}
using (var connection = new MySqlConnection(ConnString.ConnectionString))
{
var commandString =
(
"DELETE ClientContract " +
" WHERE UID = @UID "
);
using (var command = new MySqlCommand(
commandString, connection))
{
command.Parameters.Add("@UID", MySqlDbType.VarChar).Value = clientContract.UID;
connection.Open();
command.ExecuteNonQuery();
}
}
return(ret);
}
/// <summary>
/// List client contracts
/// </summary>
/// <param name="clientID"></param>
internal static List <ClientContract> List(int clientID)
{
List <ClientContract> clientContractList = new List <ClientContract>();
using (var connection = new MySqlConnection(ConnString.ConnectionString))
{
var commandString = string.Format(
" SELECT " +
ClientContractFieldsString() +
" FROM ClientContract " +
" WHERE FKCompanyUID = {0}",
clientID);
using (var command = new MySqlCommand(
commandString, connection))
{
connection.Open();
using (MySqlDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
ClientContract _clientContract = new ClientContract();
LoadClientContractObject(reader, _clientContract);
clientContractList.Add(_clientContract);
}
}
}
}
return(clientContractList);
}
private void SetScreenFieldsFromObject(ClientContract clientContract)
{
if (dgvClientContract.SelectedRows.Count <= 0)
{
return;
}
var selectedRow = dgvClientContract.SelectedRows;
txtContractID.Text = selectedRow[0].Cells[FCMDBFieldName.ClientContract.UID].Value.ToString();
txtExternalID.Text = selectedRow[0].Cells[FCMDBFieldName.ClientContract.ExternalID].Value.ToString();
dtpStartDate.Value = Convert.ToDateTime(selectedRow[0].Cells[FCMDBFieldName.ClientContract.StartDate].Value);
dtpEndDate.Value = Convert.ToDateTime(selectedRow[0].Cells[FCMDBFieldName.ClientContract.EndDate].Value);
comboBoxContractType.Text = selectedRow[0].Cells[FCMDBFieldName.ClientContract.Type].Value.ToString();
comboBoxContractStatus.Text = selectedRow[0].Cells[FCMDBFieldName.ClientContract.Status].Value.ToString();
//txtCreationDate.Text = selectedRow[0].Cells[ClientContract.FieldName.CreationDateTime].Value.ToString();
//txtUpdatedDate.Text = selectedRow[0].Cells[ClientContract.FieldName.UpdateDateTime].Value.ToString();
//txtCreatedBy.Text = selectedRow[0].Cells[ClientContract.FieldName.UserIdCreatedBy].Value.ToString();
//txtUpdatedBy.Text = selectedRow[0].Cells[ClientContract.FieldName.UserIdUpdatedBy].Value.ToString();
// Load current object
//
LoadObjectFromUIFields();
}
/// <summary>
/// Расчет превышения максимально допустимой суммы наличных расчетов ПО ОПЛАТАМ ОТ КЛИЕНТА для договора с клиентом.
/// То есть, считает сумму наличных расчетов по оплатам от клиента для всех сделок указанного договора и вычитает из нее максимально допустимую сумму.
/// </summary>
/// <param name="clientContract">Договор с клиентом.</param>
public decimal CalculateCashPaymentLimitExcessByPaymentsFromClient(ClientContract clientContract)
{
decimal totalCashPaymentSum = CalculateClientContractCashPaymentSum(clientContract);
// из суммы сделки вычитаем сумму лимита наличных расчетов для договора
return(totalCashPaymentSum - AppSettings.MaxCashPaymentSum);
}
// GET: ClientContract/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ClientContract clientContract = db.ClientContract.Find(id);
if (clientContract == null)
{
return(HttpNotFound());
}
ClientContractViewModel clientContractViewModel = new ClientContractViewModel()
{
ClientContractID = clientContract.ClientContractID,
ClientID = clientContract.ClientID,
Month = clientContract.Month,
Year = clientContract.Year,
Ammount = clientContract.Ammount,
AdditionalAmmount = clientContract.AdditionalAmmount,
};
ViewBag.ClientID = new SelectList(db.Client, "ClientID", "Name", clientContract.ClientID);
return(View(clientContractViewModel));
}
public ActionResult DeleteConfirmed(int id)
{
ClientContract clientContract = db.ClientContract.Find(id);
db.ClientContract.Remove(clientContract);
db.SaveChanges();
return(RedirectToAction("Index"));
}
/// <summary>
/// Проверка на превышение суммы оплат наличкой по сделке с учетом нового договора
/// </summary>
private void CheckForMaxCashPaymentSumExceeding(Deal deal, ClientContract clientContract)
{
var dealCashPaymentSumExceed = clientContractIndicatorService.CalculateCashPaymentLimitExcessByPaymentsFromClient(clientContract) + deal.CashDealPaymentSum;
ValidationUtils.Assert(dealCashPaymentSumExceed <= 0,
String.Format("Данная операция невозможна, так как максимально допустимая сумма наличных оплат от клиента по договору будет превышена на {0} р.",
dealCashPaymentSumExceed.ForDisplay(ValueDisplayType.Money)));
}
/// <summary>
/// Delete a client's contract
/// </summary>
/// <param name="clientContract"></param>
/// <returns></returns>
public static ResponseStatus ClientContractDelete(ClientContract clientContract)
{
var response = new ResponseStatus
{
Contents = clientContract.Delete()
};
return(response);
}
/// <summary>
/// Client contract read
/// </summary>
/// <param name="clientContractUID"> </param>
/// <returns></returns>
public static ResponseStatus Read(int clientContractUID)
{
var response = new ResponseStatus
{
Contents = ClientContract.Read(clientContractUID)
};
return(response);
}
public void UpdateClient(ClientContract clientContract)
{
var client = new Client()
{
FirstName = clientContract.FirstName,
LastName = clientContract.LastName
};
_unitOfWork.ClientRepository.Update(client);
}
//public ClientService()
//{
// _unitOfWork = new UnitOfWork();
//}
public void AddClient(ClientContract client)
{
var clientTmp = new Client()
{
FirstName = client.FirstName,
LastName = client.LastName
};
_unitOfWork.ClientRepository.Create(clientTmp);
}
public void CheckPossibilityToEditOrganization(ClientContract clientContract, User user)
{
// права
CheckPermissionToPerformOperation(clientContract, user, Permission.ClientContract_Edit);
//сущности
var deals = clientContractRepository.GetDeals(clientContract);
deals.ToList().ForEach(x => x.CheckPossibilityToEditOrganization());
}
public void DeleteClient(ClientContract client)
{
var findClient = _unitOfWork.ClientRepository.GetAll().FirstOrDefault(cl =>
cl.FirstName == client.FirstName && cl.LastName == client.LastName);
if (findClient != null)
{
_unitOfWork.ClientRepository.Delete(findClient.Id);
}
}
public static ResponseStatus GetValidContractOnDate(int clientID, DateTime date)
{
ResponseStatus ret = new ResponseStatus();
ret.Message = "Valid contract not found.";
ret.ReturnCode = 0001;
ret.ReasonCode = 0002;
ret.UniqueCode = ResponseStatus.MessageCode.Warning.FCMWAR00000002;
ClientContract clientContract = new ClientContract();
string dateString = date.ToString().Substring(0, 10);
using (var connection = new MySqlConnection(ConnString.ConnectionString))
{
var commandString =
" SELECT " +
ClientContractFieldsString() +
" FROM ClientContract " +
" WHERE FKCompanyUID = @FKCompanyUID " +
" AND StartDate <= @StartDate " +
" AND EndDate >= @EndDate ";
using (var command = new MySqlCommand(commandString, connection))
{
command.Parameters.Add("@FKCompanyUID", MySqlDbType.Int32).Value = clientID;
command.Parameters.Add("@StartDate", MySqlDbType.DateTime).Value = date;
command.Parameters.Add("@EndDate", MySqlDbType.DateTime).Value = date;
connection.Open();
using (MySqlDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
ClientContract _clientContract = new ClientContract();
LoadClientContractObject(reader, _clientContract);
clientContract = _clientContract;
ret.Message = "Valid contract found.";
ret.ReturnCode = 0001;
ret.ReasonCode = 0001;
ret.XMessageType = MessageType.Informational;
ret.UniqueCode = ResponseStatus.MessageCode.Informational.FCMINF00000001;
break;
}
}
}
}
ret.Contents = clientContract;
return(ret);
}
public void WithIInputChannel_CanBuildChannelFactoryReturnsFalse()
{
TelemetryClient client = new TelemetryClient();
ClientContract map = new ClientContract(typeof(ISimpleService));
var element = new ClientTelemetryBindingElement(client, map);
var custom = new CustomBinding(new NetMsmqBinding());
BindingContext context = new BindingContext(custom, new BindingParameterCollection());
Assert.IsFalse(element.CanBuildChannelFactory <IInputChannel>(context));
}
public static void Main(string[] args)
{
var contract = new ClientContract();
contract.ReceiveMessage += (DateTime time, string nick, string msg) => {
Console.WriteLine("[" + time.ToLongTimeString() + "] " + nick + ": " + msg);
return(true);
};
TheTunnel.LightTunnelClient <ClientContract> client = null;
while (true)
{
Console.WriteLine("Enter an ip:");
var ip = Console.ReadLine();
var port = "4242";
client = new TheTunnel.LightTunnelClient <ClientContract> ();
client.OnDisconnect += (object sender, TheTunnel.DisconnectReason reason) => {
Console.WriteLine("Server Connection is closed. Reason: " + reason);
};
try
{
client.Connect(IPAddress.Parse(ip), int.Parse(port), contract);
break;
}
catch {
Console.WriteLine("Cannot connect to " + ip);
Console.WriteLine("try again? [y]");
if (Console.ReadKey().Key != ConsoleKey.Y)
{
Console.WriteLine("Bye");
return;
}
}
}
Console.WriteLine("Succesfully connected");
while (true)
{
var msg = Console.ReadLine();
if (msg == "exit")
{
return;
}
if (!client.IsConnected)
{
return;
}
contract.SendMessage(DateTime.Now, "TNT", msg);
}
}
/// <summary>
/// Add Employee parameters to the SQL Command.
/// </summary>
/// <param name="command"></param>
private static void AddSQLParameters(MySqlCommand command, ClientContract clientContract, HeaderInfo headerInfo)
{
command.Parameters.Add(FCMDBFieldName.ClientContract.FKCompanyUID, MySqlDbType.Int32).Value = clientContract.FKCompanyUID;
command.Parameters.Add(FCMDBFieldName.ClientContract.UID, MySqlDbType.Int32).Value = clientContract.UID;
command.Parameters.Add(FCMDBFieldName.ClientContract.ExternalID, MySqlDbType.VarChar).Value = clientContract.ExternalID;
command.Parameters.Add(FCMDBFieldName.ClientContract.Status, MySqlDbType.VarChar).Value = clientContract.Status;
command.Parameters.Add(FCMDBFieldName.ClientContract.Type, MySqlDbType.VarChar).Value = clientContract.Type;
command.Parameters.Add(FCMDBFieldName.ClientContract.StartDate, MySqlDbType.DateTime).Value = clientContract.StartDate;
command.Parameters.Add(FCMDBFieldName.ClientContract.EndDate, MySqlDbType.DateTime).Value = clientContract.EndDate;
command.Parameters.Add(FCMDBFieldName.ClientContract.UserIdUpdatedBy, MySqlDbType.VarChar).Value = headerInfo.UserID;
command.Parameters.Add(FCMDBFieldName.ClientContract.UpdateDateTime, MySqlDbType.DateTime).Value = headerInfo.CurrentDateTime;
}
public bool IsPossibilityToEditOrganization(ClientContract clientContract, User user)
{
try
{
CheckPossibilityToEditOrganization(clientContract, user);
return(true);
}
catch
{
return(false);
}
}
/// <summary>
/// Расчет суммы текущих взаиморасчетов за наличный расчет по договору
/// </summary>
/// <param name="clientContract">Договор с клиентом.</param>
public decimal CalculateClientContractCashPaymentSum(ClientContract clientContract)
{
decimal totalCashPaymentSum = 0;
var deals = clientContractRepository.GetDeals(clientContract);
foreach (var deal in deals)
{
totalCashPaymentSum += deal.CashDealPaymentSum;
}
return(totalCashPaymentSum);
}
public void CanBuildDescriptionForOneWayContract()
{
var cd = ContractDescription.GetContract(typeof(IOneWayService));
var cc = new ClientContract(cd);
Assert.AreEqual(typeof(IOneWayService), cc.ContractType);
ClientOperation op;
var found = cc.TryLookupByAction("http://tempuri.org/IOneWayService/SuccessfullOneWayCall", out op);
Assert.IsTrue(found);
Assert.AreEqual(true, op.IsOneWay);
Assert.AreEqual("IOneWayService.SuccessfullOneWayCall", op.Name);
}
public UIClientContract(Form comingFromForm, Client iclient)
{
InitializeComponent();
_comingFromForm = comingFromForm;
client = iclient;
txtContractID.Enabled = false;
txtContractID.ReadOnly = true;
txtClientName.Text = client.UID + " " + client.Name;
clientContractList = new List <ClientContract>();
clientContract = new ClientContract();
}
public void CanBuildDescriptionForGenericService()
{
var cd = ContractDescription.GetContract(typeof(IRequestChannel));
var cc = new ClientContract(cd);
Assert.AreEqual(typeof(IRequestChannel), cc.ContractType);
// action doesn't exist, so we should get the generic one
ClientOperation op;
var found = cc.TryLookupByAction("http://tempuri.org/IOneWayService/SuccessfullOneWayCall", out op);
Assert.IsTrue(found);
Assert.AreEqual("IRequestChannel.Request", op.Name);
}
// GET: ClientContract/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ClientContract clientContract = db.ClientContract.Find(id);
if (clientContract == null)
{
return(HttpNotFound());
}
return(View(clientContract));
}
public void CanBuildDescriptionForTwoWayContract()
{
var cd = ContractDescription.GetContract(typeof(ISimpleService));
var cc = new ClientContract(cd);
Assert.AreEqual(typeof(ISimpleService), cc.ContractType);
ClientOperation op;
var found = cc.TryLookupByAction("http://tempuri.org/ISimpleService/GetSimpleData", out op);
Assert.IsTrue(found);
Assert.AreEqual(false, op.IsOneWay);
Assert.AreEqual("ISimpleService.GetSimpleData", op.Name);
}
public void WhenClientIsNull_ConstructorThrowsException()
{
TelemetryClient client = null;
ClientContract map = new ClientContract(typeof(ISimpleService));
bool failed = false;
try
{
var element = new ClientTelemetryBindingElement(client, map);
} catch (ArgumentNullException)
{
failed = true;
}
Assert.IsTrue(failed, "Constructor did not throw ArgumentNullException");
}
public override void HandleClientMessage(ClientContract clientContract)
{
switch (clientContract.Type)
{
case GamifyClientMessageType.CreateGame:
this.HandleCreateGame(clientContract);
break;
case GamifyClientMessageType.AcceptGame:
this.HandleAcceptGame(clientContract);
break;
case GamifyClientMessageType.RejectGame:
this.HandleRejectGame(clientContract);
break;
}
}
public ClientContract GetClientById(int id)
{
var client = _unitOfWork.ClientRepository.GetItemById(id);
if (client != null)
{
var clientContract = new ClientContract()
{
FirstName = client.FirstName,
LastName = client.LastName
};
return(clientContract);
}
return(null);
}
private void HandleAcceptGame(ClientContract clientContract)
{
var acceptGameClientMessage = this.serializer.Deserialize<AcceptGameClientMessage>(clientContract.SerializedClientMessage);
var pendingSession = this.sessionService.GetByName(acceptGameClientMessage.SessionName);
this.sessionPlayerSetup.GetPlayerReady(acceptGameClientMessage, pendingSession.Player2);
pendingSession.Player1.PendingToMove = true;
this.sessionService.Start(pendingSession);
var gameCreatedServerMessage = new GameCreatedServerMessage
{
SessionName = pendingSession.Name,
Player1Name = pendingSession.Player1Name,
Player2Name = pendingSession.Player2Name
};
this.notificationService.SendBroadcast(GamifyServerMessageType.GameCreated, gameCreatedServerMessage, pendingSession.Player1Name, pendingSession.Player2Name);
}
public void UT_When_HandleRejectGame_Then_Success()
{
this.sessionServiceMock
.Setup(s => s.GetByName(It.Is<string>(x => x == this.session.Name)))
.Returns(this.session)
.Verifiable();
var rejectGameClientMessage = new RejectGameClientMessage
{
SessionName = this.sessionName,
UserName = this.player2.Name
};
var clientContract = new ClientContract
{
Type = GamifyClientMessageType.RejectGame,
Sender = this.player2.Name,
SerializedClientMessage = this.serializer.Serialize(rejectGameClientMessage)
};
var gameCreationPluginComponent = this.GetGameCreationPluginComponent();
var canHandle = gameCreationPluginComponent.CanHandleClientMessage(clientContract);
gameCreationPluginComponent.HandleClientMessage(clientContract);
this.sessionServiceMock.VerifyAll();
this.notificationServiceMock.Verify(s => s.Send(It.Is<int>(t => t == GamifyServerMessageType.GameRejected),
It.Is<object>(o => ((GameRejectedServerMessage)o).SessionName == this.session.Name
&& ((GameRejectedServerMessage)o).Player1Name == this.session.Player1Name
&& ((GameRejectedServerMessage)o).Player2Name == this.session.Player2Name),
It.Is<string>(x => x == this.session.Player1Name)));
Assert.IsTrue(canHandle);
}
private void HandleRejectGame(ClientContract clientContract)
{
var rejectGameClientMessage = this.serializer.Deserialize<RejectGameClientMessage>(clientContract.SerializedClientMessage);
var newSession = this.sessionService.GetByName(rejectGameClientMessage.SessionName);
var gameRejectedServerMessage = new GameRejectedServerMessage
{
SessionName = newSession.Name,
Player1Name = newSession.Player1Name,
Player2Name = newSession.Player2Name
};
this.notificationService.Send(GamifyServerMessageType.GameRejected, gameRejectedServerMessage, newSession.Player1Name);
}
public override bool CanHandleClientMessage(ClientContract clientContract)
{
return clientContract.Type == GamifyClientMessageType.CreateGame ||
clientContract.Type == GamifyClientMessageType.AcceptGame ||
clientContract.Type == GamifyClientMessageType.RejectGame;
}
public void UT_When_HandleOpenGame_Then_Success()
{
var session1 = this.sessions.First(s => s.Name == this.session1Name);
var session1Player1Name = session1.Player1Name;
var session1Player2Name = session1.Player2Name;
var player1SessionHistory = new SessionHistory<TestMoveObject, TestResponseObject>(this.session1Name, session1Player1Name);
var player2SessionHistory = new SessionHistory<TestMoveObject, TestResponseObject>(this.session1Name, session1Player2Name);
this.sessionServiceMock
.Setup(s => s.GetByName(It.Is<string>(x => x == this.session1Name)))
.Returns(session1)
.Verifiable();
this.sessionHistoryServiceMock
.Setup(s => s.GetBySessionPlayer(It.Is<string>(x => x == this.session1Name), It.Is<string>(x => x == session1Player1Name)))
.Returns(player1SessionHistory)
.Verifiable();
this.sessionHistoryServiceMock
.Setup(s => s.GetBySessionPlayer(It.Is<string>(x => x == this.session1Name), It.Is<string>(x => x == session1Player2Name)))
.Returns(player2SessionHistory)
.Verifiable();
var openGameClientMessage = new OpenGameClientMessage
{
SessionName = this.session1Name,
UserName = this.requestPlayer
};
var clientContract = new ClientContract
{
Type = GamifyClientMessageType.OpenGame,
Sender = this.requestPlayer,
SerializedClientMessage = this.serializer.Serialize(openGameClientMessage)
};
var gameSelectionPluginComponent = this.GetGameSelectionPluginComponent();
var canHandle = gameSelectionPluginComponent.CanHandleClientMessage(clientContract);
gameSelectionPluginComponent.HandleClientMessage(clientContract);
this.sessionServiceMock.VerifyAll();
this.sessionHistoryServiceMock.VerifyAll();
this.notificationServiceMock.Verify(s => s.Send(It.Is<int>(t => t == GamifyServerMessageType.GameInformationReceived),
It.Is<object>(o => ((GameInformationReceivedServerMessage)o).SessionName == this.session1Name),
It.Is<string>(x => x == this.requestPlayer)));
Assert.IsTrue(canHandle);
}
public void UT_When_HandleGetPendingGames_Then_Success()
{
this.sessionServiceMock
.Setup(s => s.GetPendings(It.Is<string>(x => x == this.requestPlayer)))
.Returns(this.sessions)
.Verifiable();
var getPendingGamesClientMessage = new GetPendingGamesClientMessage
{
UserName = this.requestPlayer
};
var clientContract = new ClientContract
{
Type = GamifyClientMessageType.GetPendingGames,
Sender = this.requestPlayer,
SerializedClientMessage = this.serializer.Serialize(getPendingGamesClientMessage)
};
var gameSelectionPluginComponent = this.GetGameSelectionPluginComponent();
var canHandle = gameSelectionPluginComponent.CanHandleClientMessage(clientContract);
gameSelectionPluginComponent.HandleClientMessage(clientContract);
this.sessionServiceMock.VerifyAll();
this.notificationServiceMock.Verify(s => s.Send(It.Is<int>(t => t == GamifyServerMessageType.PendingGamesList),
It.Is<object>(o => (((PendingGamesListServerMessage)o).PendingGamesCount == 2)
&& ((PendingGamesListServerMessage)o).PlayerName == this.requestPlayer),
It.Is<string>(x => x == this.requestPlayer)));
Assert.IsTrue(canHandle);
}
private void HandleCreateGame(ClientContract clientContract)
{
var createGameClientMessage = this.serializer.Deserialize<CreateGameClientMessage>(clientContract.SerializedClientMessage);
var connectedPlayer1 = this.userService.GetByName(createGameClientMessage.UserName);
var sessionPlayer1 = this.sessionPlayerFactory.Create(connectedPlayer1);
var connectedPlayer2 = this.userService.GetByName(createGameClientMessage.InvitedUserName);
var sessionPlayer2 = this.sessionPlayerFactory.Create(connectedPlayer2);
this.sessionPlayerSetup.GetPlayerReady(createGameClientMessage, sessionPlayer1);
var newSession = this.sessionService.Create(sessionPlayer1, sessionPlayer2);
var gameInviteReceivedServerMessage = new GameInviteReceivedServerMessage
{
SessionName = newSession.Name,
Player1Name = newSession.Player1Name
};
this.gameInviteDecorator.Decorate(gameInviteReceivedServerMessage, newSession);
this.notificationService.Send(GamifyServerMessageType.GameInviteReceived, gameInviteReceivedServerMessage, newSession.Player2Name);
}
public void UT_When_HandleWinnerGameMove_Then_Success()
{
var testMoveObject = new TestMoveObject { Answer = "Test Answer" };
var testMove = new TestMove(testMoveObject);
var moveResponse = new TestResponse(new TestResponseObject { IsCorrect = true }) { IsWin = true };
var moveResultNotificationObject = Mock.Of<IMoveResultReceivedServerMessage>(o => o.SessionName == this.sessionName && o.PlayerName == this.requestPlayer);
this.sessionServiceMock
.Setup(s => s.GetByName(It.Is<string>(x => x == this.session.Name)))
.Returns(this.session)
.Verifiable();
this.moveFactoryMock
.Setup(f => f.Create(It.Is<string>(s => s == this.moveInformation)))
.Returns(testMove)
.Verifiable();
this.moveServiceMock
.Setup(s => s.Handle(It.Is<string>(x => x == this.session.Name), It.Is<string>(x => x == this.requestPlayer),
It.Is<IGameMove<TestMoveObject>>(m => m == testMove)))
.Returns(moveResponse)
.Verifiable();
this.sessionHistoryServiceMock
.Setup(x => x.Add(It.Is<string>(s => s == this.sessionName),
It.Is<string>(s => s == this.requestPlayer),
It.Is<ISessionHistoryItem<TestMoveObject, TestResponseObject>>(i => i.Move == testMove.MoveObject
&& i.Response == moveResponse.MoveResponseObject)))
.Verifiable();
this.sessionServiceMock
.Setup(s => s.Finish(It.Is<string>(x => x == this.sessionName)))
.Verifiable();
var gameProgressPluginComponent = this.GetGameProgressPluginComponent();
var gameMoveRequest = new SendMoveClientMessage
{
SessionName = this.sessionName,
UserName = this.requestPlayer,
MoveInformation = "Test"
};
var clientContract = new ClientContract
{
Type = GamifyClientMessageType.SendMove,
Sender = this.requestPlayer,
SerializedClientMessage = this.serializer.Serialize(gameMoveRequest)
};
var canHandle = gameProgressPluginComponent.CanHandleClientMessage(clientContract);
gameProgressPluginComponent.HandleClientMessage(clientContract);
this.moveServiceMock.VerifyAll();
this.sessionServiceMock.VerifyAll();
this.sessionHistoryServiceMock.VerifyAll();
this.moveFactoryMock.VerifyAll();
this.notificationServiceMock.Verify(s => s.SendBroadcast(It.Is<int>(t => t == GamifyServerMessageType.GameFinished),
It.Is<object>(o => ((GameFinishedServerMessage)o).SessionName == this.session.Name &&
((GameFinishedServerMessage)o).WinnerPlayerName == this.requestPlayer),
It.Is<string>(x => x == this.session.Player2Name),
It.Is<string>(x => x == this.session.Player1Name)));
Assert.IsTrue(canHandle);
}
public void UT_When_HandleAbandonGame_Then_Success()
{
this.sessionServiceMock
.Setup(s => s.GetByName(It.Is<string>(x => x == this.session.Name)))
.Returns(this.session)
.Verifiable();
this.sessionServiceMock
.Setup(s => s.Abandon(It.Is<string>(x => x == this.session.Name)))
.Verifiable();
var gameProgressPluginComponent = this.GetGameProgressPluginComponent();
var abandonGameClientMessage = new AbandonGameClientMessage
{
SessionName = this.sessionName,
UserName = this.requestPlayer
};
var clientContract = new ClientContract
{
Type = GamifyClientMessageType.AbandonGame,
Sender = this.requestPlayer,
SerializedClientMessage = this.serializer.Serialize(abandonGameClientMessage)
};
var canHandle = gameProgressPluginComponent.CanHandleClientMessage(clientContract);
gameProgressPluginComponent.HandleClientMessage(clientContract);
this.sessionServiceMock.VerifyAll();
this.notificationServiceMock.Verify(s => s.SendBroadcast(It.Is<int>(t => t == GamifyServerMessageType.GameAbandoned),
It.Is<object>(o => ((GameAbandonedServerMessage)o).SessionName == this.session.Name),
It.Is<string>(x => x == this.session.Player1Name),
It.Is<string>(x => x == this.session.Player2Name)));
Assert.IsTrue(canHandle);
}
public void UT_When_HandleCreateGame_Then_Success()
{
this.playerServiceMock
.Setup(s => s.GetByName(It.Is<string>(x => x == this.player1.DisplayName)))
.Returns(this.player1)
.Verifiable();
this.playerServiceMock
.Setup(s => s.GetByName(It.Is<string>(x => x == this.player2.DisplayName)))
.Returns(this.player2)
.Verifiable();
this.playerFactoryMock
.Setup(f => f.Create(It.Is<IUser>(p => p == this.player1)))
.Returns(this.sessionPlayer1)
.Verifiable();
this.playerFactoryMock
.Setup(f => f.Create(It.Is<IUser>(p => p == this.player2)))
.Returns(this.sessionPlayer2)
.Verifiable();
this.playerSetupMock.Setup(s => s.GetPlayerReady(It.Is<CreateGameClientMessage>(x => x.UserName == this.player1.DisplayName
&& x.InvitedUserName == this.player2.DisplayName),
It.Is<TestSessionPlayer>(p => p == this.sessionPlayer1)))
.Verifiable();
this.sessionServiceMock.Setup(s => s.Create(It.Is<SessionGamePlayer>(p => p == this.sessionPlayer1),
It.Is<SessionGamePlayer>(p => p == this.sessionPlayer2)))
.Returns(this.session)
.Verifiable();
this.inviteDecoratorMock
.Setup(d => d.Decorate(It.Is<GameInviteReceivedServerMessage>(n => n.SessionName == this.sessionName && n.Player1Name == this.player1.Name),
It.Is<IGameSession>(s => s == this.session)))
.Verifiable();
var createGameClientMessage = new CreateGameClientMessage
{
UserName = this.player1.DisplayName,
InvitedUserName = this.player2.DisplayName,
AdditionalInformation = "Test"
};
var clientContract = new ClientContract
{
Type = GamifyClientMessageType.CreateGame,
Sender = this.player1.DisplayName,
SerializedClientMessage = this.serializer.Serialize(createGameClientMessage)
};
var gameCreationPluginComponent = this.GetGameCreationPluginComponent();
var canHandle = gameCreationPluginComponent.CanHandleClientMessage(clientContract);
gameCreationPluginComponent.HandleClientMessage(clientContract);
this.playerServiceMock.VerifyAll();
this.sessionServiceMock.VerifyAll();
this.playerFactoryMock.VerifyAll();
this.playerSetupMock.VerifyAll();
this.inviteDecoratorMock.VerifyAll();
this.notificationServiceMock.Verify(s => s.Send(It.Is<int>(t => t == GamifyServerMessageType.GameInviteReceived),
It.Is<object>(o => ((GameInviteReceivedServerMessage)o).Player1Name == this.player1.Name
&& ((GameInviteReceivedServerMessage)o).SessionName == this.sessionName),
It.Is<string>(x => x == this.player2.Name)));
Assert.IsTrue(canHandle);
}
public void UT_When_HandleAcceptGame_Then_Success()
{
this.sessionServiceMock
.Setup(s => s.GetByName(It.Is<string>(x => x == this.session.Name)))
.Returns(this.session)
.Verifiable();
this.sessionServiceMock
.Setup(s => s.Start(It.Is<IGameSession>(x => x.Name == this.session.Name)))
.Verifiable();
this.playerSetupMock.Setup(s => s.GetPlayerReady(It.Is<AcceptGameClientMessage>(x => x.SessionName == this.sessionName),
It.Is<TestSessionPlayer>(p => p.Information.Name == "player2")))
.Verifiable();
var acceptGameClientMessage = new AcceptGameClientMessage
{
SessionName = this.sessionName,
UserName = this.player2.Name,
AdditionalInformation = "Test"
};
var clientContract = new ClientContract
{
Type = GamifyClientMessageType.AcceptGame,
Sender = this.player2.Name,
SerializedClientMessage = this.serializer.Serialize(acceptGameClientMessage)
};
var gameCreationPluginComponent = this.GetGameCreationPluginComponent();
var canHandle = gameCreationPluginComponent.CanHandleClientMessage(clientContract);
gameCreationPluginComponent.HandleClientMessage(clientContract);
this.sessionServiceMock.VerifyAll();
this.playerSetupMock.VerifyAll();
this.notificationServiceMock.Verify(s => s.SendBroadcast(It.Is<int>(t => t == GamifyServerMessageType.GameCreated),
It.Is<object>(o => ((GameCreatedServerMessage)o).SessionName == this.session.Name),
It.Is<string>(x => x == this.session.Player1Name),
It.Is<string>(x => x == this.session.Player2Name)));
Assert.IsTrue(canHandle);
Assert.IsTrue(this.session.Player1.PendingToMove);
Assert.IsFalse(this.session.Player2.PendingToMove);
}
