public OfferManager(
ISteamHubConnections steamHubConnections,
IOfferService offerService,
RpcSteamListener steamListener,
ILogServiceFactory logger,
IGrpcServiceFactory factory,
IUserService userService,
IRepoServiceFactory repoServiceFactory
)
{
_rakeItemRepoService = repoServiceFactory.RakeItemRepoService;
_steamServiceClient = factory.GetSteamServiceClient(new SteamInventoryCacheManager());
_steamHubConnections = steamHubConnections;
_offerService = offerService;
_userService = userService;
_logger = logger.CreateLogger <OfferManager>();
steamListener.OnOfferStatusChanged += async(sender, offer) =>
{
_logger.Info($"Received statuscode {offer.StatusCode}");
try
{
await HandleOffer(offer);
}
catch (System.Exception e)
{
_logger.Error(offer.SteamId, null, e, new Dictionary <string, object>
{
{ "Offer", offer }
});
}
};
}
public SteamServiceTest()
{
var host = "testHost";
var port = 8080;
_realUser = new DatabaseModel.User("realUserSteamud", "realUser", "realImg", "myTradelink", DateTime.Now, DateTime.Now, false, null, 10);
_scammerUser = new DatabaseModel.User("scammerUserSteamud", "scamerUser", "fakeImg", "myTradelink1", DateTime.Now, DateTime.Now, false,
null, 20);
_realUsersItems = new List <DatabaseModel.Item>();
_scammerUsersItems = new List <DatabaseModel.Item>();
_fakedGrpcServiceFactory = A.Fake <IGrpcServiceFactory>();
_fakedBotService = A.Fake <IBotService>();
_fakeRepoServiceFacotry = A.Fake <IRepoServiceFactory>();
_fakedSteamServiceClient = A.Fake <ISteamServiceClientWrapper>();
_fakedUserRepoService = A.Fake <IUserRepoService>();
_fakedItemRepoService = A.Fake <IItemRepoService>();
_fakedItemDescRepoService = A.Fake <IItemDescriptionRepoService>();
_fakedSettingsRepoService = A.Fake <ISettingRepoService>();
_fakedOfferTransactionRepoService = A.Fake <IOfferTranascrionRepoService>();
_fakedOfferService = A.Fake <IOfferService>();
A.CallTo(() => _fakeRepoServiceFacotry.UserRepoService).Returns(_fakedUserRepoService);
A.CallTo(() => _fakeRepoServiceFacotry.ItemRepoService).Returns(_fakedItemRepoService);
A.CallTo(() => _fakeRepoServiceFacotry.SettingRepoService).Returns(_fakedSettingsRepoService);
A.CallTo(() => _fakeRepoServiceFacotry.ItemDescriptionRepoService).Returns(_fakedItemDescRepoService);
A.CallTo(() => _fakeRepoServiceFacotry.OfferTranascrionRepoService).Returns(_fakedOfferTransactionRepoService);
A.CallTo(() => _fakedUserRepoService.FindAsync("scammerUserSteamud")).Returns(_scammerUser);
A.CallTo(() => _fakedUserRepoService.FindAsync("realUserSteamud")).Returns(_realUser);
A.CallTo(() => _fakedItemRepoService.FindAsync(A <DatabaseModel.User> .That.Matches(user => user.Id == _realUser.Id)))
.Returns(_realUsersItems);
A.CallTo(() => _fakedItemRepoService.FindAsync(A <DatabaseModel.User> .That.Matches(user => user.Id == _scammerUser.Id)))
.Returns(_scammerUsersItems);
A.CallTo(() => _fakedGrpcServiceFactory.GetSteamServiceClient(A <ISteamInventoryCacheManager> ._)).Returns(_fakedSteamServiceClient);
_steamService = new SteamService(
_fakedGrpcServiceFactory,
_fakeRepoServiceFacotry,
_fakedBotService,
A.Dummy <ILogServiceFactory>(),
_fakedOfferService,
A.Dummy <ISteamInventoryCacheManager>()
);
}
public TicketService
(
IGrpcServiceFactory grpcServiceFactory,
IGmailService gmailService,
IDiscordService discordService,
ITicketHubConnections ticketHubConnections,
IHostingEnvironment env
)
{
_isDev = env.EnvironmentName.Contains("Dev");
_gmailService = gmailService;
_ticketServiceClient = grpcServiceFactory.GetTicketSercviceClient();
_discordService = discordService;
_ticketHubConnections = ticketHubConnections;
}
public TestController(
ISteamHubConnections steamHubConnections,
IMatchHubConnections matchHubConnections,
IRepoServiceFactory repoServiceFactory,
IJackpotMatchManager jackpotMatchManager,
ICoinFlipManager coinFlipManager,
IDatabaseConnectionFactory connectionFactory,
IGrpcServiceFactory grpcService
)
{
_steamHubConnections = steamHubConnections;
_repoServiceFactory = repoServiceFactory;
_jackpotMatchManager = jackpotMatchManager;
_coinFlipManager = coinFlipManager;
_discordSercviceClient = grpcService.GetDiscordSercviceClient();
}
public SteamService
(
IGrpcServiceFactory grpcServiceFactory,
IRepoServiceFactory repoServiceFactory,
IBotService botService,
ILogServiceFactory factory,
IOfferService offerService,
ISteamInventoryCacheManager cacheManager
)
{
_logService = factory.CreateLogger<SteamService>();
_repoServiceFactory = repoServiceFactory;
_botService = botService;
_offerService = offerService;
_steamServiceClient = grpcServiceFactory.GetSteamServiceClient(cacheManager);
}
public ChatService
(
IRepoServiceFactory repoServiceFactory,
IGrpcServiceFactory grpcServiceFactory,
IChatHubConnections chatHubConnections,
ISettingsService settingsService,
IStaffService staffService,
IDiscordService discordService
)
{
_repoServiceFactory = repoServiceFactory;
_chatServiceClient = grpcServiceFactory.GetChatSercviceClient();
_chatHubConnections = chatHubConnections;
_settingsService = settingsService;
_staffService = staffService;
_discordService = discordService;
}
public DiscordService(IDiscordAuthService discordAuthService, IGrpcServiceFactory grpcServiceFactory, ILogServiceFactory logger)
{
_logger = logger.CreateLogger <DiscordService>();
AuthService = discordAuthService;
_discrodClientWrapper = grpcServiceFactory.GetDiscordSercviceClient();
}
public HistoryController(IGrpcServiceFactory grpcServiceFactory)
{
_historyService = grpcServiceFactory.GetHistorySercviceClient();
}
public DiscordController(IDiscordService discordService, IGrpcServiceFactory grpcServiceFactory, ILogServiceFactory factory)
{
_discordService = discordService;
_discordSercviceClient = grpcServiceFactory.GetDiscordSercviceClient();
_logger = factory.CreateLogger <DiscordController>();
}
public OfferManagerTest()
{
_fakedSteamHubConnection = A.Fake <ISteamHubConnections>();
_fakedOfferService = A.Fake <IOfferService>();
_fakedGrpcServiceFactory = A.Fake <IGrpcServiceFactory>();
_fakedUserService = A.Fake <IUserService>();
_loggerDummy = A.Dummy <ILogServiceFactory>();
_fakedSteamServiceClient = A.Fake <ISteamServiceClientWrapper>();
_fakedRepoServiceFactory = A.Fake <IRepoServiceFactory>();
_fakedRakeItemRepo = A.Fake <IRakeItemRepoService>();
A.CallTo(() => _fakedRepoServiceFactory.RakeItemRepoService).Returns(_fakedRakeItemRepo);
_offerMinmalInfo = new OfferStatusRequest
{
Bot = new Bot
{
Username = "******",
SteamId = "botSteamId"
},
SteamId = "user Steamid",
StatusCode = int.MinValue,
StatusMessage = "",
OfferSend = new OfferStatusOffer
{
SteamOffer = new SteamOffer
{
ItemsToGive =
{
new Item {
AppId = 730, ContextId = "2", AssetId = "1"
},
new Item {
AppId = 730, ContextId = "2", AssetId = "2"
},
new Item {
AppId = 730, ContextId = "2", AssetId = "3"
},
new Item {
AppId = 730, ContextId = "2", AssetId = "4"
},
new Item {
AppId = 730, ContextId = "2", AssetId = "5"
},
new Item {
AppId = 730, ContextId = "2", AssetId = "6"
},
},
ItemsToReceive =
{
new Item {
AppId = 730, ContextId = "2", AssetId = "11"
},
new Item {
AppId = 730, ContextId = "2", AssetId = "12"
},
new Item {
AppId = 730, ContextId = "2", AssetId = "13"
},
new Item {
AppId = 730, ContextId = "2", AssetId = "14"
},
new Item {
AppId = 730, ContextId = "2", AssetId = "15"
},
new Item {
AppId = 730, ContextId = "2", AssetId = "16"
},
},
}
}
};
var userFindRes =
Task.FromResult(new DatabaseModel.User(_offerMinmalInfo.SteamId, null, null, null, DateTime.Today, DateTime.Today, false));
A.CallTo(() => _fakedUserService.FindAsync(_offerMinmalInfo.SteamId)).Returns(userFindRes);
A.CallTo(() => _fakedGrpcServiceFactory.GetSteamServiceClient(A <ISteamInventoryCacheManager> ._)).Returns(_fakedSteamServiceClient);
A.CallTo(() => _fakedSteamServiceClient.GetPlayerInfoAsync(new GetPlayerInfoRequest
{
SteamId = _offerMinmalInfo.SteamId
})).Returns(Task.FromResult(new GetPlayerInfoResponse
{
PlayerInfo = new PlayerInfo
{
Avatar = "",
PersonaName = ""
}
}));
}
public GrpcService(IGrpcServiceFactory grpcServiceFactory, ILogServiceFactory logServiceFactory)
{
_grpcServiceFactory = grpcServiceFactory;
_logService = logServiceFactory.CreateLogger <GrpcService>();
}
