/// <summary>
/// Updates the user ater mission completion.
/// </summary>
/// <param name="missionRequest">The mission request.</param>
/// <param name="missionRepository">The mission repository.</param>
/// <param name="appCountersService">The application counters service.(need to be passed for missions from the last set)</param>
/// <returns>
/// Points increase
/// </returns>
public static async Task <int> UpdateUserAfterMissionCompletion(
MissionRequest missionRequest,
IMissionRepository missionRepository,
AppCountersService appCountersService = null)
{
var currentLevelMax = levelMap[missionRequest.User.Level.Value]; //user level can't be null
var expIncrease = (ushort)(missionRequest.Mission.Difficulty * GameConstants.Experience.PerDifficultyPoint);
var pointsIncrease =
(int)Math.Round(expIncrease * GameConstants.Points.ExtraMultiplier * missionRequest.StarsCount.Value);
//stars after completion can't be null
missionRequest.User.LevelPoints += expIncrease;
missionRequest.User.Points = (missionRequest.User.Points ?? 0) + pointsIncrease;
if (missionRequest.User.LevelPoints >= currentLevelMax)
{
missionRequest.User.Level++;
missionRequest.User.LevelPoints = (ushort)(missionRequest.User.LevelPoints - currentLevelMax);
}
CalculatePersonQualities(missionRequest, true);
await MissionFinished(missionRequest, true, missionRepository, appCountersService);
return(expIncrease);
}
private static async Task CheckForLastSetAndLoadMissions(
MissionRequest missionRequest,
IMissionRepository missionRepository,
User user,
string changedSetId,
bool lastSetExist)
{
var finishedSet = user.MissionSetIds.First(s => s.MissionSetId == changedSetId);
if (!lastSetExist)
{
MissionSetIdWithOrder newSet;
var currentOrder = finishedSet.Order + 1;
do
{
newSet = user.MissionSetIds.FirstOrDefault(s => s.Order == currentOrder);
if (newSet == null) //after 3 sets completed before test passed
{
break;
}
currentOrder++;
}while ((user.ActiveMissionSetIds.Contains(newSet.MissionSetId) ||
user.CompletedMissionSetIds.Contains(newSet.MissionSetId)));
if (newSet != null)
{
user.ActiveMissionSetIds.Add(newSet.MissionSetId);
// go to db to load missions from set, not ideal but for now is ok
await LoadMissionsFromNewSet(missionRepository, newSet.MissionSetId, missionRequest.User);
}
}
}
private static async Task <IList <string> > GetChangedSetIds(
MissionRequest missionRequest,
bool success,
IMissionRepository missionRepository,
User user,
Mission mission)
{
if (success)
{
user.CompletedMissionIds = user.CompletedMissionIds ?? new List <string>();
user.CompletedMissionIds.Add(mission.Id);
}
else
{
user.FailedMissionIds = user.FailedMissionIds ?? new List <string>();
user.FailedMissionIds.Add(mission.Id);
}
user.ActiveMissionIds.RemoveAll(m => m.MissionId == mission.Id);
var autoRemovedActiveMissions = await CheckActiveMissionDependencies(missionRequest, success, missionRepository);
var changedSetIds = autoRemovedActiveMissions.Select(m => m.MissionSetId).ToIList();
if (!changedSetIds.Contains(mission.MissionSetId))
{
changedSetIds.Add(mission.MissionSetId);
}
return(changedSetIds);
}
public MissionTrackerViewModel()
{
Missions = new ObservableCollection <MissionAcceptedEvent>();
Cargo = new ObservableCollection <Cargo>();
MissionRequirements = new ObservableCollection <MissionCargo>();
ProblemStations = new ObservableCollection <ProblemStation>();
BindingOperations.EnableCollectionSynchronization(Missions, sMissionsLock);
BindingOperations.EnableCollectionSynchronization(Cargo, sCargoLock);
BindingOperations.EnableCollectionSynchronization(MissionRequirements, sMissionCargoLock);
BindingOperations.EnableCollectionSynchronization(ProblemStations, sProblemStationsLock);
Missions.CollectionChanged += new NotifyCollectionChangedEventHandler(calculateMissionRequirements);
mRepository = MissionSqlLiteRepository.Instance;
foreach (var cargo in mRepository.loadAllCargo().AsEnumerable())
{
Cargo.Add(new Cargo(cargo.Key, cargo.Value));
}
foreach (var json in mRepository.loadAllMissions())
{
var journalEvent = (MissionAcceptedEvent)JournalMonitor.ParseJournalEntry(json);
Missions.Add(journalEvent);
}
mDatabaseHandler = new NotifyCollectionChangedEventHandler(updateDatabase);
Missions.CollectionChanged += mDatabaseHandler;
DeleteSelectedMission = new RelayCommand(deleteMission, () => SelectedMission != null);
CalculateProblematicStations = new RelayCommand(() => new ProblematicDestinationCalculator(this).calculate());
}
private static async Task MissionFinished(
MissionRequest missionRequest,
bool success,
IMissionRepository missionRepository,
AppCountersService appCountersService)
{
var user = missionRequest.User;
var mission = missionRequest.Mission;
var changedSetIds = await GetChangedSetIds(missionRequest, success, missionRepository, user, mission);
var lastSetExist = changedSetIds.Contains(GameConstants.MissionSet.LastSetId);
foreach (var changedSetId in changedSetIds)
{
var hasOtherSetMissions = user.ActiveMissionIds.Any(m => m.MissionSetId == changedSetId);
if (!hasOtherSetMissions)
{
user.ActiveMissionSetIds.Remove(changedSetId);
user.CompletedMissionSetIds = user.CompletedMissionSetIds ?? new List <string>();
user.CompletedMissionSetIds.Add(changedSetId);
await CheckForLastSetAndLoadMissions(missionRequest, missionRepository, user, changedSetId, lastSetExist);
}
}
await CheckLastSetCounters(missionRequest, appCountersService);
UpdateThreeStarsAchievement(user, missionRequest.StarsCount);
}
public MainWindow()
{
InitializeComponent();
window = this;
IKernel kernel;
kernel = new StandardKernel(new NinjectConfigModule());
resourceRepo = kernel.Get <IResourceRepository>();
planetRepo = kernel.Get <IPlanetRepository>();
missionRepo = kernel.Get <IMissionRepository>();
fractionRepo = kernel.Get <IFractionRepository>();
typeRepo = kernel.Get <IMissionTypeRepository>();
pausedRepo = kernel.Get <IPausedMissionRepository>();
endedRepo = kernel.Get <IEndedMissionRepository>();
planetSer = kernel.Get <IPlanetService>();
missionSer = kernel.Get <IMissionService>();
resourceSer = kernel.Get <IResourceService>();
resourceCollection = new ObservableCollection <string>();
planetCollection = new ObservableCollection <string>();
missionCollection = new ObservableCollection <string>();
resourcesListBox.ItemsSource = resourceCollection;
planetsListBox.ItemsSource = planetCollection;
missionsListBox.ItemsSource = missionCollection;
resourcesListBox.SelectionChanged += new SelectionChangedEventHandler(ResourceListBox_Click);
planetsListBox.SelectionChanged += new SelectionChangedEventHandler(PlanetListBox_Click);
missionsListBox.SelectionChanged += new SelectionChangedEventHandler(MissionListBox_Click);
FillDatabase();
LoadResources();
}
private static async Task <List <MissionIdWithSetId> > CheckActiveMissionDependencies(
MissionRequest missionRequest,
bool success,
IMissionRepository missionRepository)
{
var autoRemovedActiveMissions = new List <MissionIdWithSetId>();
if (success)
{
return(autoRemovedActiveMissions);
}
var user = missionRequest.User;
var declinedMissionId = missionRequest.Mission.Id;
var activeMissionsIds = user.ActiveMissionIds.Select(m => m.MissionId).ToIList();
var activeMissions =
(await
missionRepository.GetMissions(
new QueryOptions <Mission>
{
Filter =
ExpressionHelper.Expr((Mission x) => x.Id).In(activeMissionsIds),
Select = mission => new { mission.Id, mission.DependsOn }
}));
AutoDeclineActiveMissions(
declinedMissionId,
activeMissions,
user,
autoRemovedActiveMissions);
return(autoRemovedActiveMissions);
}
public HomeController(
TMDbContext dbContext,
ICustomerCouponRepository customerCouponRepo,
IContactRepository contactRepo,
IMissionRepository missionRepo,
IMemberRepository memberRepo,
UserManager <AuthUser> userManager,
SignInManager <AuthUser> signInManager,
RoleManager <AuthRole> roleManager,
IMailService emailSender,
ISmsService smsSender,
ILoggerFactory loggerFactory,
IConfigurationRoot config,
IHostingEnvironment env)
{
_TMDbContext = dbContext;
_customerCouponRepo = customerCouponRepo;
_contactRepo = contactRepo;
_missionRepo = missionRepo;
_memberRepo = memberRepo;
_userManager = userManager;
_signInManager = signInManager;
_roleManager = roleManager;
_emailSender = emailSender;
_smsSender = smsSender;
_logger = loggerFactory.CreateLogger <HomeController>();
_config = config;
_env = env;
}
public MissionService(IMissionRepository missionRepository, IFractionRepository fractionRepository, IMissionTypeRepository missionTypeRepository, IPausedMissionRepository pausedMissionRepository, IEndedMissionRepository endedMissionRepository)
{
_missionRepository = missionRepository;
_fractionRepository = fractionRepository;
_missionTypeRepository = missionTypeRepository;
_endedMissionRepository = endedMissionRepository;
_pausedMissionRepository = pausedMissionRepository;
}
public MissionService(IUnitOfWork uow, IMissionRepository missionRepository)
{
if (uow == null || missionRepository == null)
{
throw new ArgumentNullException();
}
this.uow = uow;
this.missionRepository = missionRepository;
}
public HomeController(IMissionRepository missionRepository, ICorporationRepository corporationRepository, ISectorRepository sectorRepository,
IUnitRepository unitRepository, IItemRepository itemRepository)
{
_missionRepository = missionRepository;
_corporationRepository = corporationRepository;
_sectorRepository = sectorRepository;
_unitRepository = unitRepository;
_itemRepository = itemRepository;
}
/// <summary>
/// Initializes a new instance of the <see cref="FriendBase" /> class.
/// </summary>
/// <param name="missionRepository">The mission repository.</param>
/// <param name="userRepository">The user repository.</param>
/// <param name="appCountersService">The application counters service.</param>
public FriendBase(
IMissionRepository missionRepository,
IUserRepository userRepository,
AppCountersService appCountersService)
{
_missionRepository = missionRepository;
_userRepository = userRepository;
_appCountersService = appCountersService;
}
public GameInitializer(IRegionRepository regionRepo,
IDroneRepository droneRepo,
IMissionRepository missionRepo,
ISignalSender signalSender)
{
_regionRepo = regionRepo;
_droneRepo = droneRepo;
_missionRepo = missionRepo;
_signalSender = signalSender;
}
public void Init()
{
_repository = new UserIdentityRepository();
_missionRepository = new MissionRepository();
_userRepository = new UserRepository();
_ratingRepository = new RatingRepository();
_service = new UserIdentityService(_repository);
_userService = new UserService(_userRepository, _missionRepository, _ratingRepository, new AppCountersService(new AppCountersRepository()));
_controller = new UserIdentityController(_userService, _service, new MailService(null, _repository), null);
}
/// <summary>
/// Initializes a new instance of the <see cref="QuestionService" /> class.
/// </summary>
/// <param name="questionRepository">The question repository.</param>
/// <param name="userRepository">The user repository.</param>
/// <param name="missionRepository">The mission repository.</param>
/// <param name="assignmentService">The assignment service.</param>
public QuestionService(
IQuestionRepository questionRepository,
IUserRepository userRepository,
IMissionRepository missionRepository,
AssignmentService assignmentService)
{
_questionRepository = questionRepository;
_userRepository = userRepository;
_assignmentService = assignmentService;
_missionRepository = missionRepository;
}
/// <summary>
/// Initializes a new instance of the <see cref="UserService" /> class.
/// </summary>
/// <param name="userRepository">The user repository.</param>
/// <param name="missionRepository">The mission repository.</param>
/// <param name="ratingRepository">The rating repository.</param>
/// <param name="appCountersService">The application counters service.</param>
public UserService(
IUserRepository userRepository,
IMissionRepository missionRepository,
IRatingRepository ratingRepository,
AppCountersService appCountersService)
{
_userRepository = userRepository;
_ratingRepository = ratingRepository;
_missionRepository = missionRepository;
_appCountersService = appCountersService;
}
public MissionController(
IMissionRepository missionRepository,
IOperationsRepository operationRepository,
IHubContext <NotificationHub> notificationHub,
IMapper mapper
)
{
_missionRepository = missionRepository;
_operationRepository = operationRepository;
_notificationHub = notificationHub;
_mapper = mapper;
}
public void Init()
{
_repository = new MissionRepository();
_personQualityRepository = new PersonQualityRepository();
_userRepository = new UserRepository();
_ratingRepository = new RatingRepository();
_commonPlacesRepository = new CommonPlacesRepository();
_commonPlacesService = new CommonPlacesService(_commonPlacesRepository);
_ratingService = new RatingService(_userRepository, _ratingRepository, true);
_service = new MissionService(_repository, _userRepository, new MissionSetRepository(), new MissionRequestRepository(), new HintRequestRepository(), _ratingService, _commonPlacesRepository);
_personQualityService = new PersonQualityService(_personQualityRepository);
_controller = new MissionController(_personQualityService, _service, _commonPlacesService);
}
/// <summary>
/// Updates the user ater mission decline.
/// </summary>
/// <param name="missionRequest">The mission request.</param>
/// <param name="missionRepository">The mission repository.</param>
/// <param name="appCountersService">The application counters service.</param>
/// <returns>
/// If not empty returns the set id, so active missions need to be populated
/// </returns>
public static async Task UpdateUserAfterMissionDecline(
MissionRequest missionRequest,
IMissionRepository missionRepository,
AppCountersService appCountersService = null)
{
var pointsDecrease =
(ushort)
(missionRequest.Mission.Difficulty * GameConstants.Experience.PerDifficultyPoint
* GameConstants.Points.ExtraMultiplier);
missionRequest.User.Points = (missionRequest.User.Points ?? 0) - pointsDecrease;
CalculatePersonQualities(missionRequest, false);
await MissionFinished(missionRequest, false, missionRepository, appCountersService);
}
private static async Task LoadMissionsFromNewSet(
IMissionRepository missionRepository,
string newSetId,
User user)
{
var newMissions =
(await
missionRepository.GetMissions(
new QueryOptions <Mission>
{
Select = mission => new { mission.Id, mission.DependsOn },
Filter = mission => mission.MissionSetId == newSetId
}));
AutoDeclineNewMissions(newSetId, newMissions, user);
}
/// <summary>
/// Initializes a new instance of the <see cref="MissionRequestService" /> class.
/// </summary>
/// <param name="missionRequestRepository">The mission request repository.</param>
/// <param name="missionRepository">The mission repository.</param>
/// <param name="userRepository">The user repository.</param>
/// <param name="commonPlacesRepository">The _common places repository.</param>
/// <param name="ratingService">The rating service.</param>
/// <param name="notificationService">The notification service.</param>
/// <param name="appCountersService">The application counters service.</param>
public MissionRequestService(
IMissionRequestRepository missionRequestRepository,
IMissionRepository missionRepository,
IUserRepository userRepository,
ICommonPlacesRepository commonPlacesRepository,
RatingService ratingService,
NotificationService notificationService,
AppCountersService appCountersService)
{
_missionRequestRepository = missionRequestRepository;
_missionRepository = missionRepository;
_userRepository = userRepository;
_ratingService = ratingService;
_notificationService = notificationService;
_appCountersService = appCountersService;
_commonPlacesRepository = commonPlacesRepository;
}
/// <summary>
/// Initializes a new instance of the <see cref="MissionService" /> class.
/// </summary>
/// <param name="missionRepository">The mission repository.</param>
/// <param name="userRepository">The user repository.</param>
/// <param name="missionSetRepository">The mission set repository.</param>
/// <param name="missionRequestRepository">The mission request repository.</param>
/// <param name="hintRequestRepository">The hint request repository.</param>
/// <param name="ratingService">The rating service.</param>
/// <param name="commonPlacesRepository">The common places repository.</param>
public MissionService(
IMissionRepository missionRepository,
IUserRepository userRepository,
IMissionSetRepository missionSetRepository,
IMissionRequestRepository missionRequestRepository,
IHintRequestRepository hintRequestRepository,
RatingService ratingService,
ICommonPlacesRepository commonPlacesRepository)
{
_missionRepository = missionRepository;
_userRepository = userRepository;
_ratingService = ratingService;
_missionSetRepository = missionSetRepository;
_missionRequestRepository = missionRequestRepository;
_hintRequestRepository = hintRequestRepository;
_commonPlacesRepository = commonPlacesRepository;
}
public DetectedObjectController(
IDetectedObjectRepository detectedObjectRepository,
IOperationsRepository operationRepository,
IMissionRepository missionRepository,
IUserRepository userRepository,
IHubContext <NotificationHub> notificationHub,
IClusteringService clusteringService,
IMapper mapper
)
{
_detectedObjectRepository = detectedObjectRepository;
_operationRepository = operationRepository;
_missionRepository = missionRepository;
_userRepository = userRepository;
_clusteringService = clusteringService;
_notificationHub = notificationHub;
_mapper = mapper;
}
public static async Task <MissionCompletionResult> ProcessIncorrectTry(
MissionRequest request,
IMissionRepository missionRepository,
IMissionRequestRepository missionRequestRepository)
{
Expression <Func <MissionRequest, bool> > filter =
a => a.MissionId == request.MissionId && a.UserId == request.UserId;
var previousRequiests =
await missionRequestRepository.GetMissionRequests(new QueryOptions <MissionRequest> {
Filter = filter
});
var tryCount = previousRequiests.Count + 1;
if (tryCount >= request.Mission.TriesFor1Star)
{
request.DeclineReason = "Увы, достигнуто максимальное количество попыток.";
await RewardsCalculator.UpdateUserAfterMissionDecline(request, missionRepository);
await missionRequestRepository.AddMissionRequest(request);
return(new MissionCompletionResult
{
MissionCompletionStatus = MissionCompletionStatus.Fail,
Description = request.DeclineReason
});
}
var rejectResult = new MissionCompletionResult
{
MissionCompletionStatus =
MissionCompletionStatus.IntermediateFail,
TryCount = tryCount
};
var failedRequesResult = await missionRequestRepository.AddMissionRequest(request);
return(failedRequesResult.Status != OperationResultStatus.Success
? MissionCompletionResult.FromOperationResult(failedRequesResult)
: rejectResult);
}
/// <summary>
/// Sets the new mission sets.
/// </summary>
/// <param name="user">The user.</param>
/// <param name="missionRepository">The mission repository.</param>
/// <returns></returns>
public static async Task SetNewMissionSets(User user, IMissionRepository missionRepository)
{
if (user.ActiveMissionSetIds != null && user.ActiveMissionSetIds.Count >= GameConstants.MissionSet.MaxSetsPerUser)
{
return;
}
MissionSetIdWithOrder newSet;
var currentOrder = GameConstants.MissionSet.MaxSetsPerUser;
do
{
newSet = user.MissionSetIds.First(s => s.Order == currentOrder);
user.ActiveMissionSetIds = user.ActiveMissionSetIds ?? new List <string>();
user.ActiveMissionSetIds.Add(newSet.MissionSetId);
// go to db to load missions from set, not ideal but for now is ok
await LoadMissionsFromNewSet(missionRepository, newSet.MissionSetId, user);
currentOrder++;
}while (user.ActiveMissionSetIds.Count < GameConstants.MissionSet.MaxSetsPerUser &&
newSet.MissionSetId != GameConstants.MissionSet.LastSetId);
}
public MissionController(IMissionRepository missionRepository)
{
_missRepo = missionRepository;
}
/// <summary>
/// Initializes a new instance of the <see cref="Radar" /> class.
/// </summary>
/// <param name="missionRepository">The mission repository.</param>
/// <param name="missionRequestRepository">The mission request repository.</param>
public Radar(IMissionRepository missionRepository, IMissionRequestRepository missionRequestRepository)
{
_missionRepository = missionRepository;
_missionRequestRepository = missionRequestRepository;
}
public AssignmentService(IMissionSetRepository missionSetRepository, IMissionRepository missionRepository)
{
_missionSetRepository = missionSetRepository;
_missionRepository = missionRepository;
}
/// <summary>
/// Initializes a new instance of the <see cref="MissionBusiness" /> class.
/// </summary>
/// <param name="repository">Implementation of repository</param>
public MissionBusiness(IMissionRepository repository)
{
this.missionRepository = repository;
}
public PlanetService(IPlanetRepository planetRepository, IResourceRepository resourceRepository, IMissionRepository missionRepository)
{
_planetRepository = planetRepository;
_resourceRepository = resourceRepository;
_missionRepository = missionRepository;
}
/// <summary>
/// Initializes a new instance of the <see cref="Censored"/> class.
/// </summary>
/// <param name="missionRepository">The mission repository.</param>
/// <param name="appCountersService">The app counters service.</param>
public Censored(IMissionRepository missionRepository, AppCountersService appCountersService)
{
_missionRepository = missionRepository;
_appCountersService = appCountersService;
}
