private static void InitGameData()
{
using (var fs = new WzFileSystem {
BaseDir = Constants.GameDataPath
})
{
fs.Init(Constants.GameDataPath + @"img\Data");
var sw = new Stopwatch();
sw.Start();
Task.WaitAll(Task.Run(() => { StringData = new StringProvider(fs); }),
Task.Run(() => { EquipTemplates = new EquipProvider(fs); }),
Task.Run(() => { ItemOptionTemplates = new ItemOptionProvider(fs); }),
Task.Run(() => { ItemTemplates = new ItemProvider(fs); }),
Task.Run(() => { QuestTemplates = new QuestProvider(fs); }),
Task.Run(() => { MobSkillTemplates = new MobSkillProvider(fs); }),
Task.Run(() => { SkillTemplates = new SkillProvider(fs); }),
Task.Run(() => { ItemMakeTemplates = new ItemMakeProvider(fs); }),
Task.Run(() => { CommodityProvider = new CashCommodityProvider(fs); }),
Task.Run(() => { PackageProvider = new CashPackageProvider(fs); }),
Task.Run(() => { NpcTemplates = new NpcProvider(fs); }),
Task.Run(() => { ReactorTemplates = new ReactorProvider(fs); }),
Task.Run(() => { MapTemplates = new MapProvider(fs); }),
Task.Run(() => { MobTemplates = new MobProvider(fs); })
);
sw.Stop();
Log.Info("Startup seconds elapsed: " + sw.ElapsedMilliseconds / 1000);
}
}
private bool TryValidatePackagesFile(string packagesFile, out IList <string> appPackages)
{
appPackages = new List <string>();
if (!packagesFile.EndsWith(".zip"))
{
Logger.Error(string.Format(StringProvider.GetString(Strings.ValidatePackageNoZip), packagesFile));
return(false);
}
if (!File.Exists(packagesFile))
{
Logger.Error(string.Format(StringProvider.GetString(Strings.ValidatePackageNonExistant), packagesFile));
return(false);
}
using (var archive = new ZipArchive(new FileStream(packagesFile, FileMode.Open)))
{
var validPackages = archive.Entries.Where(x => x.Name.EndsWith(".appxupload"));
if (!validPackages.Any())
{
Logger.Error(string.Format(StringProvider.GetString(Strings.ValidatePackageNoPackages), packagesFile));
return(false);
}
foreach (var entry in archive.Entries.Where(x => x.Name.EndsWith(".appxupload")))
{
appPackages.Add(entry.Name);
}
}
return(true);
}
public async Task TestSubmitSuccess()
{
var client = A.Fake <IStoreClient>();
A.CallTo(() => client.Login("myId", "myKey", "myTenantId")).Returns(Task.Factory.StartNew(() => true));
var json = File.ReadAllText($"{this.GetExecutingPath()}\\Files\\submission.json");
A.CallTo(() => client.CreateSubmission("myapp")).Returns(Task.Factory.StartNew(() => new Tuple <JObject, HttpStatusCode>(JObject.Parse(json), HttpStatusCode.Created)));
var updatedJson = File.ReadAllText($"{this.GetExecutingPath()}\\Files\\submissionupdate.json");
A.CallTo(() => client.UpdateSubmission("myapp", "submissionid", JObject.Parse(updatedJson).ToString())).Returns(Task.Factory.StartNew(() => true));
A.CallTo(() => client.Commit("myapp", "submissionid")).Returns(Task.Factory.StartNew(() => true));
var logger = new MockLogger();
var stringprovider = new StringProvider();
var command = new SubmitCommand(client, logger, stringprovider);
var packageFileLocation = $"{this.GetExecutingPath()}\\Files\\package.zip";
var options = new SubmitOptions
{
PackagesFile = packageFileLocation,
Application = "myapp",
ConfigFile = $"{this.GetExecutingPath()}\\Files\\.valid_config"
};
var result = await command.CreateSubmission(options);
result.Should().BeGreaterOrEqualTo(0, "the zip file contains app packages and everything worked out ok");
logger.Message.Last().Should().Be(stringprovider.GetString(Strings.SubmitCommitSuccess), "everything went according to plan");
A.CallTo(() => client.Login("myId", "myKey", "myTenantId")).MustHaveHappened();
A.CallTo(() => client.CreateSubmission("myapp")).MustHaveHappened();
A.CallTo(() => client.UpdateSubmission("myapp", "submissionid", JObject.Parse(updatedJson).ToString())).MustHaveHappened();
A.CallTo(() => client.Commit("myapp", "submissionid")).MustHaveHappened();
}
public async Task GivenAllDataProvided_WhenAddBooking_ShouldAddEntity()
{
// Arrange
var LAddBookingCommand = new AddBookingCommand
{
GuestFullName = StringProvider.GetRandomString(),
GuestPhoneNumber = StringProvider.GetRandomString(),
BedroomsNumber = 1,
DateFrom = FDateTimeService.Now.AddDays(5),
DateTo = FDateTimeService.Now.AddDays(15)
};
var LDatabaseContext = GetTestDatabaseContext();
await RoomsFactory(10, LDatabaseContext);
var LAddBookingCommandHandler = new AddBookingCommandHandler(LDatabaseContext);
// Act
await LAddBookingCommandHandler.Handle(LAddBookingCommand, CancellationToken.None);
// Assert
var LBookingEntity = LDatabaseContext.Bookings.ToList();
LBookingEntity.Should().HaveCount(1);
LBookingEntity[0].GuestFullName.Should().Be(LAddBookingCommand.GuestFullName);
LBookingEntity[0].GuestPhoneNumber.Should().Be(LAddBookingCommand.GuestPhoneNumber);
LBookingEntity[0].DateFrom.Should().BeSameDateAs(LAddBookingCommand.DateFrom);
LBookingEntity[0].DateTo.Should().BeSameDateAs(LAddBookingCommand.DateTo);
}
public async Task TestCommitFlightFailure()
{
var client = A.Fake <IStoreClient>();
A.CallTo(() => client.Login("myId", "myKey", "myTenantId")).Returns(Task.Factory.StartNew(() => true));
var json = File.ReadAllText($"{this.GetExecutingPath()}\\Files\\flight.json");
A.CallTo(() => client.CreateSubmission("myapp", "myflight")).Returns(Task.Factory.StartNew(() => new Tuple <JObject, HttpStatusCode>(JObject.Parse(json), HttpStatusCode.Created)));
var updatedJson = File.ReadAllText($"{this.GetExecutingPath()}\\Files\\flightupdate.json");
A.CallTo(() => client.UpdateSubmission("myapp", "myflight", "submissionid", JObject.Parse(updatedJson).ToString())).Returns(Task.Factory.StartNew(() => true));
A.CallTo(() => client.Commit("myapp", "myflight", "submissionid")).Returns(Task.Factory.StartNew(() => false));
var logger = new MockLogger();
var stringprovider = new StringProvider();
var command = new SubmitCommand(client, logger, stringprovider);
var packageFileLocation = $"{this.GetExecutingPath()}\\Files\\package.zip";
var options = new SubmitOptions
{
PackagesFile = packageFileLocation,
Application = "myapp",
ConfigFile = $"{this.GetExecutingPath()}\\Files\\.valid_config",
Flight = "myflight"
};
var result = await command.CreateSubmission(options);
result.Should().BeNegative("committing the submission failed");
logger.Message.Last().Should().Be(stringprovider.GetString(Strings.SubmitCommitError), "committing the submission failed");
A.CallTo(() => client.Login("myId", "myKey", "myTenantId")).MustHaveHappened();
A.CallTo(() => client.CreateSubmission("myapp", "myflight")).MustHaveHappened();
A.CallTo(() => client.UpdateSubmission("myapp", "myflight", "submissionid", JObject.Parse(updatedJson).ToString())).MustHaveHappened();
A.CallTo(() => client.Commit("myapp", "myflight", "submissionid")).MustHaveHappened();
}
public async Task TestSubmitNewFlightSubmissionFailure()
{
var client = A.Fake <IStoreClient>();
A.CallTo(() => client.Login("myId", "myKey", "myTenantId")).Returns(Task.Factory.StartNew(() => true));
var json = File.ReadAllText($"{this.GetExecutingPath()}\\Files\\submission.json");
A.CallTo(() => client.CreateSubmission("myapp", "myflight")).Returns(Task.Factory.StartNew(() => new Tuple <JObject, HttpStatusCode>(JObject.Parse(json), HttpStatusCode.NotFound)));
var logger = new MockLogger();
var stringprovider = new StringProvider();
var command = new SubmitCommand(client, logger, stringprovider);
var packageFileLocation = $"{this.GetExecutingPath()}\\Files\\package.zip";
var options = new SubmitOptions
{
PackagesFile = packageFileLocation,
Application = "myapp",
ConfigFile = $"{this.GetExecutingPath()}\\Files\\.valid_config",
Flight = "myflight"
};
var result = await command.CreateSubmission(options);
result.Should().BeNegative("the creation of submission failed");
logger.Message.Last().Should().Be(stringprovider.GetString(Strings.VerifyParameters), "there's something wrong with the parameters");
A.CallTo(() => client.Login("myId", "myKey", "myTenantId")).MustHaveHappened();
A.CallTo(() => client.CreateSubmission("myapp", "myflight")).MustHaveHappened();
}
protected override Task <int> CommandLogic()
{
return(Task <int> .Factory.StartNew(() =>
{
Logger.Info(StringProvider.GetString(Strings.CommandNotYetImplemented));
return -1;
}));
}
public override void _Ready()
{
this.Connect("about_to_show", this, nameof(OnPopup));
_gameSignals = (GameSignals)GetNode("/root/GameSignals");
_gameSignals.Connect(nameof(GameSignals.UpdateUI), this, nameof(UpdateUI));
_stringProvider = (StringProvider)GetNode("/root/StringProvider");
_gameController = (GameController)GetNode("/root/GameController");
}
public void createRemoveSpaces()
{
StringProvider RemoveSpaces = new StringProvider(components);
((System.ComponentModel.ISupportInitialize)(RemoveSpaces)).BeginInit();
RemoveSpaces.ProviderName = "RemoveSpaces";
RemoveSpaces.DisplayName = "RemoveSpaces";
RemoveSpaces.GetString += RemoveSpaces_GetString;
((System.ComponentModel.ISupportInitialize)(RemoveSpaces)).EndInit();
}
public override void _Ready()
{
_nextTurn = (Button)GetNode(NextTurnPath);
_gameController = (GameController)GetNode("/root/GameController");
_gameSignals = (GameSignals)GetNode("/root/GameSignals");
_yearLabel = (Label)GetNode("ToolBarContainer/VBoxContainer/year_label");
//_gameSignals.Connect(nameof(GameSignals.UpdateUI), this, nameof(UpdateElement));
_gameSignals.Connect(nameof(GameSignals.YearChanged), this, nameof(UpdateElement));
_stringProvider = (StringProvider)GetNode("/root/StringProvider");
}
public void createRemoveSpaces()
{
StringProvider RemoveSpaces = new StringProvider(components);
((System.ComponentModel.ISupportInitialize)(RemoveSpaces)).BeginInit();
RemoveSpaces.ProviderName = "RemoveSpaces";
RemoveSpaces.DisplayName = "RemoveSpaces";
RemoveSpaces.GetString += RemoveSpaces_GetString;
((System.ComponentModel.ISupportInitialize)(RemoveSpaces)).EndInit();
}
public async Task GivenCorrectId_WhenRemoveBooking_ShouldSucceed()
{
// Arrange
var LDatabaseContext = GetTestDatabaseContext();
var LRemoveBookingCommandHandler = new RemoveBookingCommandHandler(LDatabaseContext);
var LRoom = new Rooms
{
RoomNumber = 101,
Bedrooms = 3
};
await LDatabaseContext.Rooms.AddAsync(LRoom);
await LDatabaseContext.SaveChangesAsync();
var LBookings = new List <Bookings>
{
new ()
{
RoomId = LRoom.Id,
GuestFullName = StringProvider.GetRandomString(),
GuestPhoneNumber = StringProvider.GetRandomString(9),
DateFrom = FDateTimeService.Now.AddDays(5),
DateTo = FDateTimeService.Now.AddDays(15)
},
new ()
{
RoomId = LRoom.Id,
GuestFullName = StringProvider.GetRandomString(),
GuestPhoneNumber = StringProvider.GetRandomString(9),
DateFrom = FDateTimeService.Now.AddDays(1),
DateTo = FDateTimeService.Now.AddDays(3)
}
};
await LDatabaseContext.Bookings.AddRangeAsync(LBookings);
await LDatabaseContext.SaveChangesAsync();
var LBookingOne = LBookings[0].Id;
var LBookingTwo = LBookings[1].Id;
// Act
await LRemoveBookingCommandHandler
.Handle(new RemoveBookingCommand { Id = LBookingTwo }, CancellationToken.None);
// Assert
var LAssertDbContext = GetTestDatabaseContext();
var LArticlesEntity = await LAssertDbContext.Bookings.FindAsync(LBookingTwo);
LArticlesEntity.Should().BeNull();
}
}
private void ResetStatExecuted()
{
string title = StringProvider.GetString("Stat_Reset_Title");
string message = StringProvider.GetString("Stat_Reset_Message");
if (MessageBoxHelper.ShowYesNo(title, message))
{
service.ResetStatistics();
OnPropertyChanged("");
}
}
public MainWindow()
{
InitializeComponent();
var sp = new StringProvider();
ViewModel = new MainWindowViewModel();
ViewModel.Greeting = string.Concat(sp.GetGreeting(), " ", sp.GetConference(), sp.GetPunctuation());
this.DataContext = ViewModel;
this.StringEncoder = new StringUtilities(EncodingFormats.ASCII);
this.CertificateStore = new Dictionary <string, Certificate>();
}
public void GameObjectsToString()
{
string text = "";
foreach (GameObject tile in allObjects)
{
text += tile.tag.ToString();
text += "-";
text += tile.transform.position.ToString();
text += "; ";
}
codeText.text = StringProvider.Encode(text);
}
public async Task WhenGetRoomsInfo_ShouldReturnsCollection()
{
// Arrange
var LDatabaseContext = GetTestDatabaseContext();
var LGetRoomsInfoQueryHandler = new GetRoomsInfoQueryHandler(LDatabaseContext);
var LRoom = new Rooms
{
RoomNumber = 101,
Bedrooms = 3
};
await LDatabaseContext.Rooms.AddAsync(LRoom);
await LDatabaseContext.SaveChangesAsync();
var LBookings = new List <Bookings>
{
new ()
{
RoomId = LRoom.Id,
GuestFullName = StringProvider.GetRandomString(),
GuestPhoneNumber = StringProvider.GetRandomString(9),
DateFrom = FDateTimeService.Now.AddDays(5),
DateTo = FDateTimeService.Now.AddDays(15)
},
new ()
{
RoomId = LRoom.Id,
GuestFullName = StringProvider.GetRandomString(),
GuestPhoneNumber = StringProvider.GetRandomString(9),
DateFrom = FDateTimeService.Now.AddDays(1),
DateTo = FDateTimeService.Now.AddDays(3)
}
};
await LDatabaseContext.Bookings.AddRangeAsync(LBookings);
await LDatabaseContext.SaveChangesAsync();
// Act
var LResults = (await LGetRoomsInfoQueryHandler
.Handle(new GetRoomsInfoQuery(), CancellationToken.None))
.ToList();
// Assert
LResults.Should().NotBeNull();
LResults.Should().HaveCount(1);
LResults[0].Info.Should().Be("1 room with 3 bedrooms.");
}
}
public async Task TestConfigFailure(string fileName, Strings expectedMessage)
{
var client = A.Fake <IStoreClient>();
var logger = new MockLogger();
var stringprovider = new StringProvider();
var command = new MockCommandBase(client, logger, stringprovider);
var options = new OptionsBase
{
ConfigFile = $"{this.GetExecutingPath()}\\Files\\{fileName}"
};
var result = await command.DoCommand(options);
logger.Message.ElementAt(logger.Message.Count - 2).Should().Be(string.Format(stringprovider.GetString(expectedMessage), options.ConfigFile), "because there is something wrong with the config file");
result.Should().BeNegative("the config file is invalid");
}
private async Task <bool> UpdateSubmission(SubmitOptions submitOptions, string submissionId, JObject body)
{
bool updateResult;
Logger.InfoWithProgress(StringProvider.GetString(Strings.SubmitUpdating));
if (string.IsNullOrWhiteSpace(submitOptions.Flight))
{
updateResult = await Client.UpdateSubmission(submitOptions.Application, submissionId, body.ToString());
}
else
{
updateResult = await Client.UpdateSubmission(submitOptions.Application, submitOptions.Flight, submissionId, body.ToString());
}
Logger.StopProgress();
return(updateResult);
}
/// <summary>
/// Configures the bootstrapper.
/// </summary>
protected override void Configure()
{
AddCustomNamingConventions();
this._container =
new CompositionContainer(
new AggregateCatalog(AssemblySource.Instance.Select(assembly => new AssemblyCatalog(assembly))));
var batch = new CompositionBatch();
batch.AddExportedValue <IWindowManager>(new WindowManager());
batch.AddExportedValue <IEventAggregator>(new EventAggregator());
using (FileStream equipmentStream = File.OpenRead("Content/Data/equipment.pzeqp"))
{
var equipmentProvider = new EquipmentProvider(equipmentStream);
batch.AddExportedValue <IEquipmentProvider>(equipmentProvider);
}
using (FileStream heroStream = File.OpenRead("Content/Data/heroes.xml"))
{
HeroProvider heroProvider = HeroProvider.LoadFrom(heroStream);
batch.AddExportedValue <IHeroProvider>(heroProvider);
}
using (FileStream bonusStream = File.OpenRead("Content/Data/exp.pzdat"))
{
var bonusProvider = new BonusProvider(bonusStream);
batch.AddExportedValue <IBonusProvider>(bonusProvider);
}
using (FileStream stringStream = File.OpenRead("Content/Data/strings.pzdat"))
{
var stringProvider = new StringProvider(stringStream);
batch.AddExportedValue <IStringProvider>(stringProvider);
using (FileStream awardStream = File.OpenRead("Content/Data/awards.pzdat"))
{
var awardProvider = new AwardProvider(awardStream, stringProvider);
batch.AddExportedValue <IAwardProvider>(awardProvider);
}
}
batch.AddExportedValue(this._container);
this._container.Compose(batch);
}
private async Task SetupDependencies()
{
var stringProvider = new StringProvider(Windows.ApplicationModel.Resources.ResourceLoader.GetForViewIndependentUse());
var exportProvider = new ControlPaletteExportProvider();
var navModel = new MainNavModel(stringProvider);
await navModel.InitializeData(stringProvider.GetString("MainDataPath"), exportProvider);
lock (_initLock)
{
_stringProvider = stringProvider;
_exportProvider = exportProvider;
_mainNavModel = navModel;
_outerNavViewModel = new OuterNavViewModel(_mainNavModel.NavItems, _mainNavModel.DefaultNavItem);
}
}
public async Task TestLoginSuccess()
{
var client = A.Fake <IStoreClient>();
A.CallTo(() => client.Login("myId", "myKey", "myTenantId")).Returns(Task.Factory.StartNew(() => true));
var logger = new MockLogger();
var stringprovider = new StringProvider();
var command = new MockCommandBase(client, logger, stringprovider);
var options = new OptionsBase
{
ConfigFile = $"{this.GetExecutingPath()}\\Files\\.valid_config"
};
var result = await command.DoCommand(options);
result.Should().BeGreaterOrEqualTo(0, "client credentials do not match");
A.CallTo(() => client.Login("myId", "myKey", "myTenantId")).MustHaveHappened();
}
public void GivenAllFieldsAreCorrect_WhenAddBooking_ShouldSucceed()
{
// Arrange
var LAddBookingCommand = new AddBookingCommand
{
GuestFullName = StringProvider.GetRandomString(),
GuestPhoneNumber = StringProvider.GetRandomString(9),
BedroomsNumber = 1,
DateFrom = FDateTimeService.Now.AddDays(10),
DateTo = FDateTimeService.Now.AddDays(20)
};
// Act
var LValidator = new AddBookingCommandValidator(FDateTimeService);
var LResult = LValidator.Validate(LAddBookingCommand);
// Assert
LResult.Errors.Should().BeEmpty();
}
public void GivenGuestPhoneNumberTooLong_WhenAddBooking_ShouldThrowError()
{
// Arrange
var LAddBookingCommand = new AddBookingCommand
{
GuestFullName = StringProvider.GetRandomString(),
GuestPhoneNumber = StringProvider.GetRandomString(15),
BedroomsNumber = 1,
DateFrom = FDateTimeService.Now.AddDays(10),
DateTo = FDateTimeService.Now.AddDays(20)
};
// Act
var LValidator = new AddBookingCommandValidator(FDateTimeService);
var LResult = LValidator.Validate(LAddBookingCommand);
// Assert
LResult.Errors.Count.Should().Be(1);
LResult.Errors[0].ErrorCode.Should().Be(nameof(ValidationCodes.PHONE_NUMBER_TOO_LONG));
}
public async Task TestSubmitZipfileNoPackages()
{
var client = A.Fake <IStoreClient>();
A.CallTo(() => client.Login("myId", "myKey", "myTenantId")).Returns(Task.Factory.StartNew(() => true));
var logger = new MockLogger();
var stringprovider = new StringProvider();
var command = new SubmitCommand(client, logger, stringprovider);
var packageFileLocation = $"{this.GetExecutingPath()}\\Files\\nopackage.zip";
var options = new SubmitOptions
{
PackagesFile = packageFileLocation,
Application = "myapp",
ConfigFile = $"{this.GetExecutingPath()}\\Files\\.valid_config"
};
var result = await command.CreateSubmission(options);
result.Should().BeNegative("the zip file does not contain app packages");
logger.Message.Last().Should().Be(Format(stringprovider.GetString(Strings.ValidatePackageNoPackages), packageFileLocation), "The provided zip file does not contain any packages");
A.CallTo(() => client.Login("myId", "myKey", "myTenantId")).MustHaveHappened();
}
public void GivenDateFromAndDateToAreSame_WhenAddBooking_ShouldThrowError(DateTime ADateFrom, DateTime ADateTo, TestCaseDays ACase)
{
// Arrange
var LAddBookingCommand = new AddBookingCommand
{
GuestFullName = StringProvider.GetRandomString(),
GuestPhoneNumber = StringProvider.GetRandomString(9),
BedroomsNumber = 1,
DateFrom = ADateFrom,
DateTo = ADateTo
};
// Act
var LValidator = new AddBookingCommandValidator(FDateTimeService);
var LResult = LValidator.Validate(LAddBookingCommand);
// Assert
if (ACase is TestCaseDays.Present or TestCaseDays.Future)
{
LResult.Errors.Count.Should().Be(1);
LResult.Errors[0].ErrorCode.Should().Be(nameof(ValidationCodes.START_DATE_AND_END_DATE_CANNOT_BE_SAME));
}
private async Task <JObject> NewSubmission(SubmitOptions submitOptions)
{
Tuple <JObject, HttpStatusCode> deployResult;
Logger.InfoWithProgress(StringProvider.GetString(Strings.SubmitCreating));
if (string.IsNullOrWhiteSpace(submitOptions.Flight))
{
deployResult = await Client.CreateSubmission(submitOptions.Application);
}
else
{
deployResult = await Client.CreateSubmission(submitOptions.Application, submitOptions.Flight);
}
Logger.StopProgress();
if (deployResult.Item2.Equals(HttpStatusCode.Created))
{
return(deployResult.Item1);
}
Logger.Error(StringProvider.GetString(Strings.SubmitCreateError));
Logger.Info(StringProvider.GetString(Strings.VerifyParameters));
return(null);
}
/// <summary>
/// Convert a travel type to text.
/// </summary>
/// <param name="value"></param>
/// <param name="targetType"></param>
/// <param name="parameter"></param>
/// <param name="culture"></param>
/// <returns></returns>
public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
if (value != null)
{
TravelType travelType = (TravelType)value;
switch (travelType)
{
case TravelType.Unknown:
return(StringProvider.GetString("TravelTypeUnkown"));
case TravelType.OneWay:
return(StringProvider.GetString("TravelTypeOneWay"));
case TravelType.Roundtrip:
return(StringProvider.GetString("TravelTypeRoundTrip"));
default:
break;
}
}
return(null);
}
public async Task <IHttpActionResult> GetIntentionListAsync(int page, int pageSize, string keyword = "", string intention = "", string orderBy = "")
{
var intentions = StringProvider.SpiltToNumbers <int>(",", intention);
var pageList = await this.m_IntentionStorage.GetPagedListAsync(page, pageSize, keyword ?? "", intentions, orderBy);
var data = new
{
list = pageList.RowSet.Select(i => new
{
i.id,
i.name,
i.phone,
i.intention,
i.useragent,
i.remark,
intention_text = GetIntentionText(i.intention),
i.created
}),
count = pageList.Count
};
return(Json(JsonApiResult.Ok(data)));
}
private async Task <bool> CommitSubmission(SubmitOptions submitOptions, string submissionId)
{
bool commitResult;
Logger.InfoWithProgress(StringProvider.GetString(Strings.SubmitCommitting));
if (string.IsNullOrWhiteSpace(submitOptions.Flight))
{
commitResult = await Client.Commit(submitOptions.Application, submissionId);
}
else
{
commitResult = await Client.Commit(submitOptions.Application, submitOptions.Flight, submissionId);
}
Logger.StopProgress();
if (commitResult)
{
Logger.Info(StringProvider.GetString(Strings.SubmitCommitSuccess));
}
else
{
Logger.Error(StringProvider.GetString(Strings.SubmitCommitError));
}
return(commitResult);
}
/// <summary>
/// Flow:
/// <para>* Create new submission using POST (Success == HttpStatusCode 201 Created)</para>
/// <para>* Get the JSON object and mark all packages as PendingDelete</para>
/// <para>* Add the new packages from the zip as PendingUpload</para>
/// <para>* Upload the changes using PUT (entire JSON in body)</para>
/// <para>* Upload the zip file</para>
/// <para>* Commit the changes to trigger the submission</para>
/// </summary>
/// <returns>StatusCode of the command.</returns>
protected override async Task <int> CommandLogic()
{
IList <string> packages;
if (!TryValidatePackagesFile(_submitOptions.PackagesFile, out packages))
{
return(-1);
}
//Create new submission using POST(Success == HttpStatusCode 201 Created)
var submission = await NewSubmission(_submitOptions);
if (submission == null)
{
return(-1);
}
// Get the JSON object and mark all packages as PendingDelete
submission = UpdatePackages(_submitOptions, submission, packages);
// Add the changes using PUT(entire JSON in body)
var idReference = string.IsNullOrWhiteSpace(_submitOptions.Flight) ? "id" : "submissionId";
var updateSuccess = await UpdateSubmission(_submitOptions, submission[idReference].ToString(), submission);
if (updateSuccess)
{
// Upload the zip file
Logger.InfoWithProgress(StringProvider.GetString(Strings.SubmitUploading));
await Client.UploadPackages(_submitOptions.PackagesFile, submission["fileUploadUrl"].ToString());
Logger.StopProgress();
// Commit the changes
var commitResult = await CommitSubmission(_submitOptions, submission[idReference].ToString());
return(commitResult ? 0 : -1);
}
Logger.Error(StringProvider.GetString(Strings.SubmitUpdateError));
return(-1);
}
public HomeController(StringProvider<HomeController> localizer)
{
_localizer = localizer;
}
protected override void OnCreate(Bundle savedInstanceState)
{
if (savedInstanceState == null)
{
var prefs = PreferenceManager.GetDefaultSharedPreferences(this);
AppCompatDelegate.DefaultNightMode = prefs.GetBoolean("NightMode", default) ?
AppCompatDelegate.ModeNightYes : AppCompatDelegate.ModeNightNo;
#warning fix on release
int firstLaunch;
try
{
firstLaunch = prefs.GetInt(PreferencesConstants.FirstLaunch, launchCode);
}
catch
{
firstLaunch = launchCode;
}
if (firstLaunch == launchCode)
{
prefs.Edit().Clear().Apply();
prefs.Edit().PutInt(PreferencesConstants.FirstLaunch, launchCode + 1).Apply();
}
this.ScheduleVmPreloadTask = Task.Run(() => PrepareSchdeuleVm(prefs));
}
SetTheme(Resource.Style.AppTheme_NoActionBar);
base.OnCreate(savedInstanceState);
SetContentView(Resource.Layout.activity_main);
Xamarin.Essentials.Platform.Init(this, savedInstanceState);
if (this.loggerFactory == null)
{
this.loggerFactory = DependencyInjector.GetILoggerFactory();
}
StringProvider.Context = this;
AssetProvider.AssetManager = this.Assets;
StringProvider.SetUpLogger(this.loggerFactory);
if (savedInstanceState == null)
{
ChangeFragment(ScheduleView.NewInstance(this.ScheduleVmPreloadTask), true);
//SplashView.ScheduleVmPreloadTask = null;
}
else
{
// TODO: Fix stack
//ChangeFragment(this.SupportFragmentManager.GetBackStackEntryAt(0)., Fragments.ScheduleMain, false);
}
ActivityCompat.RequestPermissions(this,
new string[] { Android.Manifest.Permission.Internet }, 123);
this.logger = this.loggerFactory.Create <MainView>();
var navigationView = FindViewById <NavigationView>(Resource.Id.nav_view);
navigationView.NavigationItemSelected += (obj, arg) => OnNavigationItemSelected(arg.MenuItem);
navigationView.SetCheckedItem(Resource.Id.nav_schedule);
this.clickBackAgain = GetString(Resource.String.click_back_again);
this.doubleBackToExitPressedOnce = false;
PreferenceManager.GetDefaultSharedPreferences(this)
.RegisterOnSharedPreferenceChangeListener(this);
this.logger.Debug("MainActivity created successfully");
}
