public static void SaveProfile()
{
lock (opLock)
{
if (Profile == null)
{
throw new InvalidOperationException("Profile not set.");
}
if (currentProfileName == null)
{
throw new InvalidOperationException("Profile name not set.");
}
Profile.SaveTime = GlobalTime.Current;
var directory = GetProfilesDirectory();
var path = Path.Combine(directory, currentProfileName);
var newFilePath = $"{path}.new";
var backupPath = $"{path}.backup";
Directory.CreateDirectory(directory);
if (File.Exists(newFilePath))
{
File.Delete(newFilePath);
}
try
{
using (var stream = new FileStream(newFilePath, FileMode.Create, FileAccess.Write, FileShare.None))
using (var writer = new StreamWriter(stream))
using (var jsonWriter = new JsonTextWriter(writer))
{
var settings = new JsonSerializerSettings()
{
TypeNameHandling = TypeNameHandling.Auto
};
JsonSerializer.Create(settings).Serialize(jsonWriter, Profile);
}
}
catch (Exception e)
{
throw new GameException(0, e, "Failed to serialize profile.");
}
// TODO: Check if everything is alright with just saved profile
if (File.Exists(path))
{
try
{
if (File.Exists(backupPath))
{
File.Delete(backupPath);
}
File.Move(path, backupPath);
}
catch (Exception e)
{
throw new GameException(1, e, "Failed to create profile backup.");
}
}
File.Move(newFilePath, path);
}
}
public void DeserializeRequest(Message message, object[] parameters)
{
foreach (var part in operationParameters.Where(p => p.IsFromProperty))
{
if (message.Properties.TryGetValue(part.Name, out object property))
{
parameters[part.Index] = property;
}
else
{
throw new ArgumentException("Required parameter was not provided.", part.Name);
}
}
var filledParts = new bool[operationParameters.Count];
using (var reader = GetJsonReaderAtMessageBody(message))
{
if (!reader.Read() || !reader.Read())
{
throw new JsonReaderException("Error reading the request");
}
while (reader.TokenType != JsonToken.EndObject)
{
if (reader.TokenType != JsonToken.PropertyName)
{
throw new JsonReaderException("Error reading the request");
}
var part = operationParameters.FirstOrDefault(x => x.Name == (string)reader.Value);
if (part.Name == null) // skip unexpected properties
{
reader.Read();
switch (reader.TokenType)
{
case JsonToken.StartArray:
case JsonToken.StartObject:
reader.Skip();
break;
}
reader.Read();
continue;
}
if (!reader.Read())
{
throw new JsonReaderException("Error reading the request");
}
try
{
var v = JsonSerializer.Create(settingsProvider()).Deserialize(reader, part.Type);
if (!reader.Read())
{
throw new JsonReaderException("Error reading the request");
}
if (v == null && part.IsRequired)
{
throw new ArgumentException("Required parameter was not provided.", part.Name);
}
parameters[part.Index] = v;
}
catch (ArgumentException ex) when(ex.ParamName == part.Name)
{
throw;
}
catch (Exception ex)
{
throw new ArgumentException("Error retrieving parameter value", part.Name, ex);
}
filledParts[part.Index] = true;
}
}
var notFilled = operationParameters.FirstOrDefault(p => !p.IsFromProperty && p.IsRequired && !filledParts[p.Index]);
if (notFilled.IsRequired)
{
throw new ArgumentException("Required parameter was not provided.", notFilled.Name);
}
}
public static T Deserialize <T>(byte[] data) where T : class
{
using (var stream = new MemoryStream(data))
using (var reader = new StreamReader(stream, Encoding.UTF8))
return(JsonSerializer.Create().Deserialize(reader, typeof(T)) as T);
}
public static void BuildSampleSpec(string outputFileName)
{
var floatRate_Libor3m = new TO_FloatRateIndex()
{
Currency = "USD",
DayCountBasis = DayCountBasis.Act360,
FixingOffset = "2b",
HolidayCalendars = "NYC+LON",
ResetTenor = "3m",
RollConvention = RollType.MF,
ResetTenorFixed = "3m"
};
var floatRate_FedFunds = new TO_FloatRateIndex()
{
Currency = "USD",
DayCountBasis = DayCountBasis.Act360,
FixingOffset = "0b",
HolidayCalendars = "NYC",
ResetTenor = "1m",
ResetTenorFixed = "1m",
RollConvention = RollType.MF,
};
var o = new ModelBuilderSpec
{
RateIndices = new Dictionary <string, TO_FloatRateIndex>
{
{ "USD.LIBOR.3M", floatRate_Libor3m },
{ "USD.OIS.1B", floatRate_FedFunds },
},
NymexSpecs = new List <ModelBuilderSpecNymex>
{
new ModelBuilderSpecNymex {
QwackCode = "CL", NymexCodeFuture = "CL", NymexCodeOption = "LO"
}, //WTI
new ModelBuilderSpecNymex {
QwackCode = "CO", NymexCodeFuture = "BB", NymexCodeOption = "BZO"
}, //Brent
//new ModelBuilderSpecNymex {QwackCode="Dated",NymexCodeFuture="UB"},//Dated Brent
new ModelBuilderSpecNymex {
QwackCode = "NG", NymexCodeFuture = "NG", NymexCodeOption = "ON"
}, //HH
new ModelBuilderSpecNymex {
QwackCode = "UkNbp", NymexCodeFuture = "UKG"
}, //UK Gas
new ModelBuilderSpecNymex {
QwackCode = "HO", NymexCodeFuture = "HO", NymexCodeOption = "OH"
}, //Heat
new ModelBuilderSpecNymex {
QwackCode = "XB", NymexCodeFuture = "RB", NymexCodeOption = "OB"
}, //RBOB
new ModelBuilderSpecNymex {
QwackCode = "QS", NymexCodeFuture = "7F"
}, //ICE Gasoil
new ModelBuilderSpecNymex {
QwackCode = "Sing0.5", NymexCodeFuture = "S5M"
}, //0.5% Sing
new ModelBuilderSpecNymex {
QwackCode = "Sing180", NymexCodeFuture = "UA"
}, //Sing180
new ModelBuilderSpecNymex {
QwackCode = "Sing380", NymexCodeFuture = "SE"
}, //Sing380
new ModelBuilderSpecNymex {
QwackCode = "NWE3.5", NymexCodeFuture = "0D"
}, //3.5% NWE
new ModelBuilderSpecNymex {
QwackCode = "NWE1.0", NymexCodeFuture = "0B"
}, //1.0% NWE
new ModelBuilderSpecNymex {
QwackCode = "NWE0.5", NymexCodeFuture = "R5M"
}, //0.5% NWE
new ModelBuilderSpecNymex {
QwackCode = "XO", NymexCodeFuture = "MFF"
}, //API4
new ModelBuilderSpecNymex {
QwackCode = "XA", NymexCodeFuture = "MTF"
}, //API2
new ModelBuilderSpecNymex {
QwackCode = "IronOre62", NymexCodeFuture = "TIO"
}, //62% Iron Ore TSI
},
CmeBaseCurveSpecs = new List <ModelBuilderSpecCmeBaseCurve>
{
new ModelBuilderSpecCmeBaseCurve {
CmeCode = "ED", QwackCode = "ED", CurveName = "USD.LIBOR.3M", FloatRateIndex = "USD.LIBOR.3M", IsCbot = false
},
new ModelBuilderSpecCmeBaseCurve {
CmeCode = "41", QwackCode = "FF", CurveName = "USD.OIS.1B", FloatRateIndex = "USD.OIS.1B", IsCbot = true
},
},
CmeBasisCurveSpecs = new List <ModelBuilderSpecCmeBasisCurve>
{
new ModelBuilderSpecCmeBasisCurve {
CmeFxPair = "USDZRC", Currency = "ZAR", CurveName = "ZAR.DISC.[USD.LIBOR.3M]", FxPair = "USDZAR", BaseCurveName = "USD.LIBOR.3M"
},
new ModelBuilderSpecCmeBasisCurve {
CmeFxPair = "USDJYC", Currency = "JPY", CurveName = "JPY.DISC.[USD.LIBOR.3M]", FxPair = "USDJPY", BaseCurveName = "USD.LIBOR.3M"
},
new ModelBuilderSpecCmeBasisCurve {
CmeFxPair = "EURUSN", Currency = "EUR", CurveName = "EUR.DISC.[USD.LIBOR.3M]", FxPair = "EURUSD", BaseCurveName = "USD.LIBOR.3M"
},
new ModelBuilderSpecCmeBasisCurve {
CmeFxPair = "GBPUSN", Currency = "GBP", CurveName = "GPB.DISC.[USD.LIBOR.3M]", FxPair = "GBPUSD", BaseCurveName = "USD.LIBOR.3M"
},
new ModelBuilderSpecCmeBasisCurve {
CmeFxPair = "USDCAC", Currency = "CAD", CurveName = "CAD.DISC.[USD.LIBOR.3M]", FxPair = "USDCAD", BaseCurveName = "USD.LIBOR.3M"
},
new ModelBuilderSpecCmeBasisCurve {
CmeFxPair = "AUDUSN", Currency = "AUD", CurveName = "AUD.DISC.[USD.LIBOR.3M]", FxPair = "AUDUSD", BaseCurveName = "USD.LIBOR.3M"
},
new ModelBuilderSpecCmeBasisCurve {
CmeFxPair = "NZDUSC", Currency = "NZD", CurveName = "NZD.DISC.[USD.LIBOR.3M]", FxPair = "NZDUSD", BaseCurveName = "USD.LIBOR.3M"
},
new ModelBuilderSpecCmeBasisCurve {
CmeFxPair = "USDDKC", Currency = "DKK", CurveName = "DKK.DISC.[USD.LIBOR.3M]", FxPair = "USDDKK", BaseCurveName = "USD.LIBOR.3M"
},
new ModelBuilderSpecCmeBasisCurve {
CmeFxPair = "USDNKC", Currency = "NOK", CurveName = "NOK.DISC.[USD.LIBOR.3M]", FxPair = "USDNOK", BaseCurveName = "USD.LIBOR.3M"
},
new ModelBuilderSpecCmeBasisCurve {
CmeFxPair = "USDSKC", Currency = "SEK", CurveName = "SEK.DISC.[USD.LIBOR.3M]", FxPair = "USDSEK", BaseCurveName = "USD.LIBOR.3M"
},
new ModelBuilderSpecCmeBasisCurve {
CmeFxPair = "USDRUB", Currency = "RUB", CurveName = "RUB.DISC.[USD.LIBOR.3M]", FxPair = "USDRUB", BaseCurveName = "USD.LIBOR.3M"
},
new ModelBuilderSpecCmeBasisCurve {
CmeFxPair = "USDBRL", Currency = "BRL", CurveName = "BRL.DISC.[USD.LIBOR.3M]", FxPair = "USDBRL", BaseCurveName = "USD.LIBOR.3M"
},
new ModelBuilderSpecCmeBasisCurve {
CmeFxPair = "USDCNY", Currency = "CNY", CurveName = "CNY.DISC.[USD.LIBOR.3M]", FxPair = "USDCNY", BaseCurveName = "USD.LIBOR.3M"
},
new ModelBuilderSpecCmeBasisCurve {
CmeFxPair = "USDKRW", Currency = "KRW", CurveName = "KRW.DISC.[USD.LIBOR.3M]", FxPair = "USDKRW", BaseCurveName = "USD.LIBOR.3M"
},
new ModelBuilderSpecCmeBasisCurve {
CmeFxPair = "USDINR", Currency = "INR", CurveName = "INR.DISC.[USD.LIBOR.3M]", FxPair = "USDINR", BaseCurveName = "USD.LIBOR.3M"
},
new ModelBuilderSpecCmeBasisCurve {
CmeFxPair = "USDPHP", Currency = "PHP", CurveName = "PHP.DISC.[USD.LIBOR.3M]", FxPair = "USDPHP", BaseCurveName = "USD.LIBOR.3M"
},
new ModelBuilderSpecCmeBasisCurve {
CmeFxPair = "USDTWD", Currency = "TWD", CurveName = "TWD.DISC.[USD.LIBOR.3M]", FxPair = "USDTWD", BaseCurveName = "USD.LIBOR.3M"
},
},
FxPairs = new List <TO_FxPair>
{
new TO_FxPair {
Domestic = "USD", Foreign = "ZAR", PrimaryCalendar = "ZAR", SecondaryCalendar = "USD", SpotLag = "2b"
},
new TO_FxPair {
Domestic = "USD", Foreign = "JPY", PrimaryCalendar = "JPY", SecondaryCalendar = "USD", SpotLag = "2b"
},
new TO_FxPair {
Domestic = "EUR", Foreign = "USD", PrimaryCalendar = "EUR", SecondaryCalendar = "USD", SpotLag = "2b"
},
new TO_FxPair {
Domestic = "GBP", Foreign = "USD", PrimaryCalendar = "GBP", SecondaryCalendar = "USD", SpotLag = "2b"
},
new TO_FxPair {
Domestic = "USD", Foreign = "CAD", PrimaryCalendar = "CAD", SecondaryCalendar = "USD", SpotLag = "1b"
},
new TO_FxPair {
Domestic = "AUD", Foreign = "USD", PrimaryCalendar = "AUD", SecondaryCalendar = "USD", SpotLag = "2b"
},
new TO_FxPair {
Domestic = "NZD", Foreign = "USD", PrimaryCalendar = "NZD", SecondaryCalendar = "USD", SpotLag = "2b"
},
new TO_FxPair {
Domestic = "USD", Foreign = "DKK", PrimaryCalendar = "DKK", SecondaryCalendar = "USD", SpotLag = "2b"
},
new TO_FxPair {
Domestic = "USD", Foreign = "SEK", PrimaryCalendar = "SEK", SecondaryCalendar = "USD", SpotLag = "2b"
},
new TO_FxPair {
Domestic = "USD", Foreign = "NOK", PrimaryCalendar = "NOK", SecondaryCalendar = "USD", SpotLag = "2b"
},
new TO_FxPair {
Domestic = "USD", Foreign = "RUB", PrimaryCalendar = "RUB", SecondaryCalendar = "USD", SpotLag = "2b"
},
new TO_FxPair {
Domestic = "USD", Foreign = "BRL", PrimaryCalendar = "BRL", SecondaryCalendar = "USD", SpotLag = "2b"
},
new TO_FxPair {
Domestic = "USD", Foreign = "CNY", PrimaryCalendar = "CNY", SecondaryCalendar = "USD", SpotLag = "2b"
},
new TO_FxPair {
Domestic = "USD", Foreign = "KRW", PrimaryCalendar = "KRW", SecondaryCalendar = "USD", SpotLag = "2b"
},
new TO_FxPair {
Domestic = "USD", Foreign = "INR", PrimaryCalendar = "INR", SecondaryCalendar = "USD", SpotLag = "2b"
},
new TO_FxPair {
Domestic = "USD", Foreign = "PHP", PrimaryCalendar = "PHP", SecondaryCalendar = "USD", SpotLag = "2b"
},
new TO_FxPair {
Domestic = "USD", Foreign = "TWD", PrimaryCalendar = "TWD", SecondaryCalendar = "USD", SpotLag = "2b"
},
new TO_FxPair {
Domestic = "BTC", Foreign = "USD", PrimaryCalendar = "USD", SecondaryCalendar = "USD", SpotLag = "0b"
},
new TO_FxPair {
Domestic = "XAU", Foreign = "USD", PrimaryCalendar = "LON", SecondaryCalendar = "USD", SpotLag = "2b"
},
new TO_FxPair {
Domestic = "XAG", Foreign = "USD", PrimaryCalendar = "LON", SecondaryCalendar = "USD", SpotLag = "2b"
},
new TO_FxPair {
Domestic = "XPT", Foreign = "USD", PrimaryCalendar = "LON", SecondaryCalendar = "USD", SpotLag = "2b"
},
new TO_FxPair {
Domestic = "XPD", Foreign = "USD", PrimaryCalendar = "LON", SecondaryCalendar = "USD", SpotLag = "2b"
},
},
CmeFxFutureSpecs = new List <ModelBuilderSpecFxFuture>
{
new ModelBuilderSpecFxFuture {
CmeCodeFut = "6E", CmeCodeOpt = "EUU", Currency = "USD", FxPair = "EURUSD"
},
new ModelBuilderSpecFxFuture {
CmeCodeFut = "6B", CmeCodeOpt = "GBU", Currency = "USD", FxPair = "GBPUSD"
},
new ModelBuilderSpecFxFuture {
CmeCodeFut = "6J", CmeCodeOpt = "JPU", Currency = "USD", FxPair = "JPYUSD"
},
new ModelBuilderSpecFxFuture {
CmeCodeFut = "6A", CmeCodeOpt = "ADU", Currency = "USD", FxPair = "AUDUSD"
},
new ModelBuilderSpecFxFuture {
CmeCodeFut = "6C", CmeCodeOpt = "CAU", Currency = "USD", FxPair = "CADUSD"
},
new ModelBuilderSpecFxFuture {
CmeCodeFut = "6L", CmeCodeOpt = "BR", Currency = "USD", FxPair = "BRLUSD"
},
new ModelBuilderSpecFxFuture {
CmeCodeFut = "BTC", CmeCodeOpt = "BTC", Currency = "USD", FxPair = "BTCUSD"
},
},
CmxMetalCurves = new List <ModelBuilderSpecCmxMetalCurve>
{
new ModelBuilderSpecCmxMetalCurve {
Currency = "XAU", MetalPair = "XAUUSD", CmxSymbol = "GB", CurveName = "XAU.DISC.[USD.LIBOR.3M]", BaseCurveName = "USD.LIBOR.3M", CmxFutCode = "GC", CmxOptCode = "OG"
},
new ModelBuilderSpecCmxMetalCurve {
Currency = "XAG", MetalPair = "XAGUSD", CmxSymbol = "LSF", CurveName = "XAG.DISC.[USD.LIBOR.3M]", BaseCurveName = "USD.LIBOR.3M", CmxFutCode = "SI", CmxOptCode = "SO"
},
}
};
var tw = new StringWriter();
var js = JsonSerializer.Create();
js.Serialize(tw, o);
File.WriteAllText(outputFileName, tw.ToString());
}
public JsonSerializer GetJsonSerializer()
{
var jsonSerializer = JsonSerializer.Create(GetJsonSerializerSettings());
return(jsonSerializer);
}
/// <summary>
/// The operation to update a billing profile.
/// </summary>
/// <param name='billingAccountName'>
/// billing Account Id.
/// </param>
/// <param name='billingProfileName'>
/// Billing Profile Id.
/// </param>
/// <param name='parameters'>
/// Parameters supplied to the update billing profile operation.
/// </param>
/// <param name='customHeaders'>
/// Headers that will be added to request.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
/// <exception cref="ErrorResponseException">
/// Thrown when the operation returned an invalid status code
/// </exception>
/// <exception cref="SerializationException">
/// Thrown when unable to deserialize the response
/// </exception>
/// <exception cref="ValidationException">
/// Thrown when a required parameter is null
/// </exception>
/// <exception cref="System.ArgumentNullException">
/// Thrown when a required parameter is null
/// </exception>
/// <return>
/// A response object containing the response body and response headers.
/// </return>
public async Task <AzureOperationResponse <BillingProfile, BillingProfilesUpdateHeaders> > BeginUpdateWithHttpMessagesAsync(string billingAccountName, string billingProfileName, BillingProfile parameters, Dictionary <string, List <string> > customHeaders = null, CancellationToken cancellationToken = default(CancellationToken))
{
if (Client.ApiVersion == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "this.Client.ApiVersion");
}
if (billingAccountName == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "billingAccountName");
}
if (billingProfileName == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "billingProfileName");
}
if (parameters == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "parameters");
}
// Tracing
bool _shouldTrace = ServiceClientTracing.IsEnabled;
string _invocationId = null;
if (_shouldTrace)
{
_invocationId = ServiceClientTracing.NextInvocationId.ToString();
Dictionary <string, object> tracingParameters = new Dictionary <string, object>();
tracingParameters.Add("billingAccountName", billingAccountName);
tracingParameters.Add("billingProfileName", billingProfileName);
tracingParameters.Add("parameters", parameters);
tracingParameters.Add("cancellationToken", cancellationToken);
ServiceClientTracing.Enter(_invocationId, this, "BeginUpdate", tracingParameters);
}
// Construct URL
var _baseUrl = Client.BaseUri.AbsoluteUri;
var _url = new System.Uri(new System.Uri(_baseUrl + (_baseUrl.EndsWith("/") ? "" : "/")), "providers/Microsoft.Billing/billingAccounts/{billingAccountName}/billingProfiles/{billingProfileName}").ToString();
_url = _url.Replace("{billingAccountName}", System.Uri.EscapeDataString(billingAccountName));
_url = _url.Replace("{billingProfileName}", System.Uri.EscapeDataString(billingProfileName));
List <string> _queryParameters = new List <string>();
if (Client.ApiVersion != null)
{
_queryParameters.Add(string.Format("api-version={0}", System.Uri.EscapeDataString(Client.ApiVersion)));
}
if (_queryParameters.Count > 0)
{
_url += (_url.Contains("?") ? "&" : "?") + string.Join("&", _queryParameters);
}
// Create HTTP transport objects
var _httpRequest = new HttpRequestMessage();
HttpResponseMessage _httpResponse = null;
_httpRequest.Method = new HttpMethod("PUT");
_httpRequest.RequestUri = new System.Uri(_url);
// Set Headers
if (Client.GenerateClientRequestId != null && Client.GenerateClientRequestId.Value)
{
_httpRequest.Headers.TryAddWithoutValidation("x-ms-client-request-id", System.Guid.NewGuid().ToString());
}
if (Client.AcceptLanguage != null)
{
if (_httpRequest.Headers.Contains("accept-language"))
{
_httpRequest.Headers.Remove("accept-language");
}
_httpRequest.Headers.TryAddWithoutValidation("accept-language", Client.AcceptLanguage);
}
if (customHeaders != null)
{
foreach (var _header in customHeaders)
{
if (_httpRequest.Headers.Contains(_header.Key))
{
_httpRequest.Headers.Remove(_header.Key);
}
_httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
}
}
// Serialize Request
string _requestContent = null;
if (parameters != null)
{
_requestContent = Rest.Serialization.SafeJsonConvert.SerializeObject(parameters, Client.SerializationSettings);
_httpRequest.Content = new StringContent(_requestContent, System.Text.Encoding.UTF8);
_httpRequest.Content.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json; charset=utf-8");
}
// Set Credentials
if (Client.Credentials != null)
{
cancellationToken.ThrowIfCancellationRequested();
await Client.Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
}
// Send Request
if (_shouldTrace)
{
ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
}
cancellationToken.ThrowIfCancellationRequested();
_httpResponse = await Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
if (_shouldTrace)
{
ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
}
HttpStatusCode _statusCode = _httpResponse.StatusCode;
cancellationToken.ThrowIfCancellationRequested();
string _responseContent = null;
if ((int)_statusCode != 200 && (int)_statusCode != 202)
{
var ex = new ErrorResponseException(string.Format("Operation returned an invalid status code '{0}'", _statusCode));
try
{
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
ErrorResponse _errorBody = Rest.Serialization.SafeJsonConvert.DeserializeObject <ErrorResponse>(_responseContent, Client.DeserializationSettings);
if (_errorBody != null)
{
ex.Body = _errorBody;
}
}
catch (JsonException)
{
// Ignore the exception
}
ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
if (_shouldTrace)
{
ServiceClientTracing.Error(_invocationId, ex);
}
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw ex;
}
// Create Result
var _result = new AzureOperationResponse <BillingProfile, BillingProfilesUpdateHeaders>();
_result.Request = _httpRequest;
_result.Response = _httpResponse;
if (_httpResponse.Headers.Contains("x-ms-request-id"))
{
_result.RequestId = _httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault();
}
// Deserialize Response
if ((int)_statusCode == 200)
{
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
try
{
_result.Body = Rest.Serialization.SafeJsonConvert.DeserializeObject <BillingProfile>(_responseContent, Client.DeserializationSettings);
}
catch (JsonException ex)
{
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw new SerializationException("Unable to deserialize the response.", _responseContent, ex);
}
}
try
{
_result.Headers = _httpResponse.GetHeadersAsJson().ToObject <BillingProfilesUpdateHeaders>(JsonSerializer.Create(Client.DeserializationSettings));
}
catch (JsonException ex)
{
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw new SerializationException("Unable to deserialize the headers.", _httpResponse.GetHeadersAsJson().ToString(), ex);
}
if (_shouldTrace)
{
ServiceClientTracing.Exit(_invocationId, _result);
}
return(_result);
}
public static void RegisterServices(Container container, ILoggerFactory loggerFactory, CancellationToken shutdownCancellationToken)
{
var logger = loggerFactory.CreateLogger <Bootstrapper>();
container.RegisterLogger(loggerFactory);
container.RegisterSingleton <IDependencyResolver>(() => new SimpleInjectorDependencyResolver(container));
JsonConvert.DefaultSettings = () => new JsonSerializerSettings {
DateParseHandling = DateParseHandling.DateTimeOffset
};
var resolver = new DynamicTypeContractResolver(new LowerCaseUnderscorePropertyNamesContractResolver());
resolver.UseDefaultResolverFor(typeof(DataDictionary), typeof(SettingsDictionary), typeof(VersionOne.VersionOneWebHookStack), typeof(VersionOne.VersionOneWebHookEvent));
var settings = new JsonSerializerSettings {
MissingMemberHandling = MissingMemberHandling.Ignore,
DateParseHandling = DateParseHandling.DateTimeOffset,
ContractResolver = resolver
};
settings.AddModelConverters(loggerFactory.CreateLogger(nameof(Bootstrapper)));
container.RegisterSingleton <IContractResolver>(() => resolver);
container.RegisterSingleton <JsonSerializerSettings>(settings);
container.RegisterSingleton <JsonSerializer>(() => JsonSerializer.Create(settings));
container.RegisterSingleton <ISerializer>(() => new JsonNetSerializer(settings));
container.RegisterSingleton <ICacheClient>(() => new InMemoryCacheClient(new InMemoryCacheClientOptions {
LoggerFactory = loggerFactory
}));
container.RegisterSingleton <IMetricsClient>(() => new InMemoryMetricsClient(new InMemoryMetricsClientOptions {
LoggerFactory = loggerFactory
}));
container.RegisterSingleton <ExceptionlessElasticConfiguration>();
if (!Settings.Current.DisableIndexConfiguration)
{
container.AddStartupAction(() => container.GetInstance <ExceptionlessElasticConfiguration>().ConfigureIndexesAsync(beginReindexingOutdated: false));
}
container.RegisterSingleton <IEnumerable <IQueueBehavior <EventPost> > >(() => new[] { new MetricsQueueBehavior <EventPost>(container.GetInstance <IMetricsClient>()) });
container.RegisterSingleton <IEnumerable <IQueueBehavior <EventUserDescription> > >(() => new[] { new MetricsQueueBehavior <EventUserDescription>(container.GetInstance <IMetricsClient>()) });
container.RegisterSingleton <IEnumerable <IQueueBehavior <EventNotificationWorkItem> > >(() => new[] { new MetricsQueueBehavior <EventNotificationWorkItem>(container.GetInstance <IMetricsClient>()) });
container.RegisterSingleton <IEnumerable <IQueueBehavior <WebHookNotification> > >(() => new[] { new MetricsQueueBehavior <WebHookNotification>(container.GetInstance <IMetricsClient>()) });
container.RegisterSingleton <IEnumerable <IQueueBehavior <MailMessage> > >(() => new[] { new MetricsQueueBehavior <MailMessage>(container.GetInstance <IMetricsClient>()) });
container.RegisterSingleton <IEnumerable <IQueueBehavior <WorkItemData> > >(() => new[] { new MetricsQueueBehavior <WorkItemData>(container.GetInstance <IMetricsClient>()) });
var workItemHandlers = new WorkItemHandlers();
workItemHandlers.Register <ReindexWorkItem>(container.GetInstance <ReindexWorkItemHandler>);
workItemHandlers.Register <RemoveOrganizationWorkItem>(container.GetInstance <RemoveOrganizationWorkItemHandler>);
workItemHandlers.Register <RemoveProjectWorkItem>(container.GetInstance <RemoveProjectWorkItemHandler>);
workItemHandlers.Register <SetLocationFromGeoWorkItem>(container.GetInstance <SetLocationFromGeoWorkItemHandler>);
workItemHandlers.Register <SetProjectIsConfiguredWorkItem>(container.GetInstance <SetProjectIsConfiguredWorkItemHandler>);
workItemHandlers.Register <StackWorkItem>(container.GetInstance <StackWorkItemHandler>);
workItemHandlers.Register <ThrottleBotsWorkItem>(container.GetInstance <ThrottleBotsWorkItemHandler>);
workItemHandlers.Register <OrganizationMaintenanceWorkItem>(container.GetInstance <OrganizationMaintenanceWorkItemHandler>);
workItemHandlers.Register <OrganizationNotificationWorkItem>(container.GetInstance <OrganizationNotificationWorkItemHandler>);
workItemHandlers.Register <ProjectMaintenanceWorkItem>(container.GetInstance <ProjectMaintenanceWorkItemHandler>);
workItemHandlers.Register <UserMaintenanceWorkItem>(container.GetInstance <UserMaintenanceWorkItemHandler>);
container.RegisterSingleton <WorkItemHandlers>(workItemHandlers);
container.RegisterSingleton(() => CreateQueue <EventPost>(container, loggerFactory: loggerFactory));
container.RegisterSingleton(() => CreateQueue <EventUserDescription>(container, loggerFactory: loggerFactory));
container.RegisterSingleton(() => CreateQueue <EventNotificationWorkItem>(container, loggerFactory: loggerFactory));
container.RegisterSingleton(() => CreateQueue <WebHookNotification>(container, loggerFactory: loggerFactory));
container.RegisterSingleton(() => CreateQueue <MailMessage>(container, loggerFactory: loggerFactory));
container.RegisterSingleton(() => CreateQueue <WorkItemData>(container, TimeSpan.FromHours(1), loggerFactory));
container.RegisterSingleton <IMessageBus>(() => new InMemoryMessageBus(new InMemoryMessageBusOptions {
LoggerFactory = loggerFactory
}));
container.RegisterSingleton <IMessagePublisher>(container.GetInstance <IMessageBus>);
container.RegisterSingleton <IMessageSubscriber>(container.GetInstance <IMessageBus>);
if (!String.IsNullOrEmpty(Settings.Current.StorageFolder))
{
container.RegisterSingleton <IFileStorage>(() => new FolderFileStorage(Settings.Current.StorageFolder));
}
else
{
container.RegisterSingleton <IFileStorage>(() => new InMemoryFileStorage());
}
container.RegisterSingleton <IStackRepository, StackRepository>();
container.RegisterSingleton <IEventRepository, EventRepository>();
container.RegisterSingleton <IOrganizationRepository, OrganizationRepository>();
container.RegisterSingleton <IProjectRepository, ProjectRepository>();
container.RegisterSingleton <IUserRepository, UserRepository>();
container.RegisterSingleton <IWebHookRepository, WebHookRepository>();
container.RegisterSingleton <ITokenRepository, TokenRepository>();
container.RegisterSingleton <IGeoIpService, MaxMindGeoIpService>();
container.RegisterSingleton <IGeocodeService, NullGeocodeService>();
container.RegisterSingleton <IQueryParser>(() => new ElasticQueryParser());
container.Register(typeof(IValidator <>), new[] { typeof(Bootstrapper).Assembly }, Lifestyle.Singleton);
container.RegisterSingleton <IMailer, Mailer>();
container.RegisterSingleton <IMailSender>(() => new InMemoryMailSender());
container.RegisterSingleton <ILockProvider, CacheLockProvider>();
container.Register <StripeEventHandler>();
container.RegisterSingleton <BillingManager>();
container.RegisterSingleton <SampleDataService>();
container.RegisterSingleton <EventPipeline>();
container.RegisterSingleton <EventPluginManager>();
container.RegisterSingleton <FormattingPluginManager>();
container.RegisterSingleton <UserAgentParser>();
container.RegisterSingleton <SystemHealthChecker>();
container.RegisterSingleton <ICoreLastReferenceIdManager, NullCoreLastReferenceIdManager>();
container.RegisterSingleton <UsageService>();
container.RegisterSingleton <SlackService>();
container.Register <IDomainLoginProvider, ActiveDirectoryLoginProvider>();
container.AppendToCollection(typeof(Profile), typeof(CoreMappings));
container.RegisterSingleton <IMapper>(() => {
var profiles = container.GetAllInstances <Profile>();
var config = new MapperConfiguration(cfg => {
cfg.ConstructServicesUsing(container.GetInstance);
foreach (var profile in profiles)
{
cfg.AddProfile(profile);
}
});
return(config.CreateMapper());
});
}
/// <summary>
/// Deletes the specified Batch account.
/// </summary>
/// <param name='resourceGroupName'>
/// The name of the resource group that contains the Batch account.
/// </param>
/// <param name='accountName'>
/// The name of the Batch account.
/// </param>
/// <param name='customHeaders'>
/// Headers that will be added to request.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
/// <exception cref="HttpOperationException">
/// Thrown when the operation returned an invalid status code
/// </exception>
/// <exception cref="ValidationException">
/// Thrown when a required parameter is null
/// </exception>
/// <exception cref="System.ArgumentNullException">
/// Thrown when a required parameter is null
/// </exception>
/// <return>
/// A response object containing the response body and response headers.
/// </return>
public async Task <AzureOperationHeaderResponse <RetryHeader> > BeginDeleteWithHttpMessagesAsync(string resourceGroupName, string accountName, Dictionary <string, List <string> > customHeaders = null, CancellationToken cancellationToken = default(CancellationToken))
{
if (resourceGroupName == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "resourceGroupName");
}
if (resourceGroupName != null)
{
if (!System.Text.RegularExpressions.Regex.IsMatch(resourceGroupName, "^[-\\w\\._]+$"))
{
throw new ValidationException(ValidationRules.Pattern, "resourceGroupName", "^[-\\w\\._]+$");
}
}
if (accountName == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "accountName");
}
if (accountName != null)
{
if (accountName.Length > 24)
{
throw new ValidationException(ValidationRules.MaxLength, "accountName", 24);
}
if (accountName.Length < 3)
{
throw new ValidationException(ValidationRules.MinLength, "accountName", 3);
}
if (!System.Text.RegularExpressions.Regex.IsMatch(accountName, "^[-\\w\\._]+$"))
{
throw new ValidationException(ValidationRules.Pattern, "accountName", "^[-\\w\\._]+$");
}
}
if (Client.ApiVersion == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "this.Client.ApiVersion");
}
if (Client.SubscriptionId == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "this.Client.SubscriptionId");
}
// Tracing
bool _shouldTrace = ServiceClientTracing.IsEnabled;
string _invocationId = null;
if (_shouldTrace)
{
_invocationId = ServiceClientTracing.NextInvocationId.ToString();
Dictionary <string, object> tracingParameters = new Dictionary <string, object>();
tracingParameters.Add("resourceGroupName", resourceGroupName);
tracingParameters.Add("accountName", accountName);
tracingParameters.Add("cancellationToken", cancellationToken);
ServiceClientTracing.Enter(_invocationId, this, "BeginDelete", tracingParameters);
}
// Construct URL
var _baseUrl = Client.BaseUri.AbsoluteUri;
var _url = new System.Uri(new System.Uri(_baseUrl + (_baseUrl.EndsWith("/") ? "" : "/")), "subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Batch/batchAccounts/{accountName}").ToString();
_url = _url.Replace("{resourceGroupName}", System.Uri.EscapeDataString(resourceGroupName));
_url = _url.Replace("{accountName}", System.Uri.EscapeDataString(accountName));
_url = _url.Replace("{subscriptionId}", System.Uri.EscapeDataString(Client.SubscriptionId));
List <string> _queryParameters = new List <string>();
if (Client.ApiVersion != null)
{
_queryParameters.Add(string.Format("api-version={0}", System.Uri.EscapeDataString(Client.ApiVersion)));
}
if (_queryParameters.Count > 0)
{
_url += (_url.Contains("?") ? "&" : "?") + string.Join("&", _queryParameters);
}
// Create HTTP transport objects
var _httpRequest = new HttpRequestMessage();
HttpResponseMessage _httpResponse = null;
_httpRequest.Method = new HttpMethod("DELETE");
_httpRequest.RequestUri = new System.Uri(_url);
// Set Headers
if (Client.GenerateClientRequestId != null && Client.GenerateClientRequestId.Value)
{
_httpRequest.Headers.TryAddWithoutValidation("x-ms-client-request-id", System.Guid.NewGuid().ToString());
}
if (Client.AcceptLanguage != null)
{
if (_httpRequest.Headers.Contains("accept-language"))
{
_httpRequest.Headers.Remove("accept-language");
}
_httpRequest.Headers.TryAddWithoutValidation("accept-language", Client.AcceptLanguage);
}
if (customHeaders != null)
{
foreach (var _header in customHeaders)
{
if (_httpRequest.Headers.Contains(_header.Key))
{
_httpRequest.Headers.Remove(_header.Key);
}
_httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
}
}
// Serialize Request
string _requestContent = null;
// Set Credentials
if (Client.Credentials != null)
{
cancellationToken.ThrowIfCancellationRequested();
await Client.Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
}
// Send Request
if (_shouldTrace)
{
ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
}
cancellationToken.ThrowIfCancellationRequested();
_httpResponse = await Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
if (_shouldTrace)
{
ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
}
HttpStatusCode _statusCode = _httpResponse.StatusCode;
cancellationToken.ThrowIfCancellationRequested();
string _responseContent = null;
if ((int)_statusCode != 200 && (int)_statusCode != 202 && (int)_statusCode != 204)
{
var ex = new HttpOperationException(string.Format("Operation returned an invalid status code '{0}'", _statusCode));
try
{
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
object _errorBody = Microsoft.Rest.Serialization.SafeJsonConvert.DeserializeObject <object>(_responseContent, Client.DeserializationSettings);
if (_errorBody != null)
{
ex.Body = _errorBody;
}
}
catch (JsonException)
{
// Ignore the exception
}
ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
if (_shouldTrace)
{
ServiceClientTracing.Error(_invocationId, ex);
}
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw ex;
}
// Create Result
var _result = new AzureOperationHeaderResponse <RetryHeader>();
_result.Request = _httpRequest;
_result.Response = _httpResponse;
if (_httpResponse.Headers.Contains("x-ms-request-id"))
{
_result.RequestId = _httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault();
}
try
{
_result.Headers = _httpResponse.GetHeadersAsJson().ToObject <RetryHeader>(JsonSerializer.Create(Client.DeserializationSettings));
}
catch (JsonException ex)
{
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw new SerializationException("Unable to deserialize the headers.", _httpResponse.GetHeadersAsJson().ToString(), ex);
}
if (_shouldTrace)
{
ServiceClientTracing.Exit(_invocationId, _result);
}
return(_result);
}
private T Deserialize <T>(WebApiResponse response) where T : class =>
response.Ok
? response.Data?.ToObject <T>(JsonSerializer.Create(_jsonSettings.SerializerSettings))
: throw new SlackException(response.Data?.ToObject <ErrorResponse>(JsonSerializer.Create(_jsonSettings.SerializerSettings)));
public virtual async Task <T> DeserializeAsync <T>(HttpContent content)
{
if (content == null)
{
throw new ArgumentNullException(nameof(content));
}
#if DotNetStandard2_0 || UWP
using Stream stream = await content.ReadAsStreamAsync().ConfigureAwait(false);
#else
await using Stream stream = await content.ReadAsStreamAsync().ConfigureAwait(false);
#endif
using StreamReader reader = new StreamReader(stream);
using JsonTextReader jsonTextReader = new JsonTextReader(reader);
return((await JToken.LoadAsync(jsonTextReader).ConfigureAwait(false)).ToObject <T>(JsonSerializer.Create(_jsonDeserializeSettings)) !);
}
/// <summary>
/// Converts the object to a JSON writer.
/// </summary>
/// <param name="value">The value.</param>
/// <param name="settings">The settings.</param>
/// <param name="jsonWriter">The JSON writer to write JSON to.</param>
public static void ToJsonWriter(object value, JsonSettings settings, JsonWriter jsonWriter)
{
JsonSerializer serializer = JsonSerializer.Create(CreateDefaultJsonSerializerSettings(settings));
serializer.Serialize(jsonWriter, value);
}
private static KernelBase SetupNinject(IJabbrConfiguration configuration)
{
var kernel = new StandardKernel(new[] { new FactoryModule() });
kernel.Bind <JabbrContext>()
.To <JabbrContext>();
kernel.Bind <IJabbrRepository>()
.To <PersistedRepository>();
kernel.Bind <IChatService>()
.To <ChatService>();
kernel.Bind <IDataProtector>()
.To <JabbRDataProtection>();
kernel.Bind <ICookieAuthenticationProvider>()
.To <JabbRFormsAuthenticationProvider>();
kernel.Bind <ILogger>()
.To <RealtimeLogger>();
kernel.Bind <IUserIdProvider>()
.To <JabbrUserIdProvider>();
kernel.Bind <IJabbrConfiguration>()
.ToConstant(configuration);
// We're doing this manually since we want the chat repository to be shared
// between the chat service and the chat hub itself
kernel.Bind <Chat>()
.ToMethod(context =>
{
var resourceProcessor = context.Kernel.Get <ContentProviderProcessor>();
var repository = context.Kernel.Get <IJabbrRepository>();
var cache = context.Kernel.Get <ICache>();
var logger = context.Kernel.Get <ILogger>();
var settings = context.Kernel.Get <ApplicationSettings>();
var service = new ChatService(cache, repository, settings);
return(new Chat(resourceProcessor,
service,
repository,
cache,
logger));
});
kernel.Bind <ICryptoService>()
.To <CryptoService>();
kernel.Bind <IResourceProcessor>()
.ToConstant(new ResourceProcessor(kernel));
kernel.Bind <IJavaScriptMinifier>()
.To <AjaxMinMinifier>()
.InSingletonScope();
kernel.Bind <IMembershipService>()
.To <MembershipService>();
kernel.Bind <ApplicationSettings>()
.ToMethod(context =>
{
return(context.Kernel.Get <ISettingsManager>().Load());
});
kernel.Bind <ISettingsManager>()
.To <SettingsManager>();
kernel.Bind <IUserAuthenticator>()
.To <DefaultUserAuthenticator>();
kernel.Bind <IAuthenticationService>()
.To <AuthenticationService>();
kernel.Bind <IAuthenticationCallbackProvider>()
.To <JabbRAuthenticationCallbackProvider>();
kernel.Bind <ICache>()
.To <DefaultCache>()
.InSingletonScope();
kernel.Bind <IChatNotificationService>()
.To <ChatNotificationService>();
kernel.Bind <IKeyProvider>()
.To <SettingsKeyProvider>();
var serializer = JsonSerializer.Create(new JsonSerializerSettings()
{
DateFormatHandling = DateFormatHandling.IsoDateFormat
});
kernel.Bind <JsonSerializer>()
.ToConstant(serializer);
kernel.Bind <UploadCallbackHandler>()
.ToSelf()
.InSingletonScope();
kernel.Bind <UploadProcessor>()
.ToConstant(new UploadProcessor(kernel));
kernel.Bind <ContentProviderProcessor>()
.ToConstant(new ContentProviderProcessor(kernel));
kernel.Bind <IEmailTemplateContentReader>()
.To <RazorEmailTemplateContentReader>();
kernel.Bind <IEmailTemplateEngine>()
.To <RazorEmailTemplateEngine>();
kernel.Bind <IEmailSender>()
.To <SmtpClientEmailSender>();
kernel.Bind <IEmailService>()
.To <EmailService>();
return(kernel);
}
private static KernelBase SetupNinject(ChatConfiguration configuration)
{
var kernel = new StandardKernel(new[] { new FactoryModule() });
kernel.Bind <IRecentMessageCache>()
.To <NoopCache>()
.InSingletonScope();
//data layer
var dataSettingsManager = new DataSettingsManager();
var dataProviderSettings = dataSettingsManager.LoadSettings();
kernel.Bind <DataSettings>().ToMethod(context =>
{
return(dataSettingsManager.LoadSettings());
});
kernel.Bind <BaseDataProviderManager>().ToMethod(context =>
{
var recentDataSettings = context.Kernel.Get <DataSettings>();
return(new MongoDBDataProviderManager(recentDataSettings));
});
kernel.Bind <IDataProvider>().ToMethod(context =>
{
var recentBaseDataProviderManager = context.Kernel.Get <BaseDataProviderManager>();
return(recentBaseDataProviderManager.LoadDataProvider());
});
if (dataProviderSettings != null && dataProviderSettings.IsValid())
{
var mongoDBDataProviderManager = new MongoDBDataProviderManager(dataSettingsManager.LoadSettings());
var dataProvider = mongoDBDataProviderManager.LoadDataProvider();
kernel.Bind <IMongoClient>().ToMethod(context =>
{
return(new MongoClient(dataProviderSettings.DataConnectionString));
});
}
kernel.Bind(typeof(IRepository <>)).To(typeof(MongoDBRepository <>)).InSingletonScope();
kernel.Bind <IChatService>()
.To <ChatService>();
kernel.Bind <IDataProtector>()
.To <ChatDataProtection>();
kernel.Bind <ICookieAuthenticationProvider>()
.To <ChatFormsAuthenticationProvider>();
kernel.Bind <ILogger>()
.To <RealtimeLogger>();
//kernel.Bind<IUserIdProvider>()
// .To<ChatUserIdProvider>();
kernel.Bind <IChatConfiguration>()
.ToConstant(configuration);
// We're doing this manually since we want the chat repository to be shared
// between the chat service and the chat hub itself
kernel.Bind <Chat>()
.ToMethod(context =>
{
// var resourceProcessor = context.Kernel.Get<ContentProviderProcessor>();
var recentMessageCache = context.Kernel.Get <IRecentMessageCache>();
// var repository = context.Kernel.Get<IChatRepository>();
var cache = context.Kernel.Get <ICache>();
var logger = context.Kernel.Get <ILogger>();
var settings = context.Kernel.Get <ApplicationSettings>();
IRepository <ChatUser> repository = context.Kernel.Get <IRepository <ChatUser> >();
IRepository <ChatUserIdentity> chatUserIdentityRepository = context.Kernel.Get <IRepository <ChatUserIdentity> >();
IRepository <Attachment> attachmentRepository = context.Kernel.Get <IRepository <Attachment> >();
IRepository <ChatClient> chatClientRepository = context.Kernel.Get <IRepository <ChatClient> >();
IRepository <ChatMessage> chatMessagerepository = context.Kernel.Get <IRepository <ChatMessage> >();
IRepository <ChatRoom> chatRoomRepository = context.Kernel.Get <IRepository <ChatRoom> >();
IRepository <Notification> notificationRepository = context.Kernel.Get <IRepository <Notification> >();
IRepository <Settings> settingsRepository = context.Kernel.Get <IRepository <Settings> >();
var service = new ChatService(cache, repository, chatUserIdentityRepository, attachmentRepository, chatClientRepository
, chatMessagerepository, chatRoomRepository, notificationRepository, settingsRepository);
return(new Chat(repository, chatUserIdentityRepository, attachmentRepository, chatClientRepository
, chatMessagerepository, chatRoomRepository, notificationRepository, settingsRepository,
settings,
service,
cache,
logger
));
});
kernel.Bind <ICryptoService>()
.To <CryptoService>();
kernel.Bind <IJavaScriptMinifier>()
.To <AjaxMinMinifier>()
.InSingletonScope();
kernel.Bind <IMembershipService>()
.To <MembershipService>();
kernel.Bind <ApplicationSettings>()
.ToMethod(context =>
{
return(context.Kernel.Get <ISettingsManager>().Load());
});
kernel.Bind <ISettingsManager>()
.To <SettingsManager>();
kernel.Bind <IUserAuthenticator>()
.To <DefaultUserAuthenticator>();
kernel.Bind <ICache>()
.To <DefaultCache>()
.InSingletonScope();
//kernel.Bind<IChatNotificationService>()
// .To<ChatNotificationService>();
kernel.Bind <IKeyProvider>()
.To <SettingsKeyProvider>();
RegisterContentProviders(kernel);
var serializer = JsonSerializer.Create(new JsonSerializerSettings()
{
DateFormatHandling = DateFormatHandling.IsoDateFormat
});
kernel.Bind <JsonSerializer>()
.ToConstant(serializer);
return(kernel);
}
/// <summary>
/// x-ms-client-request-id = 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0 is required
/// message header for all requests. Long running post request, service returns
/// a 202 to the initial request, with an entity that contains
/// ProvisioningState=’Creating’. Poll the endpoint indicated in the
/// Azure-AsyncOperation header for operation status
/// </summary>
/// <param name='product'>
/// Product to put
/// </param>
/// <param name='customHeaders'>
/// Headers that will be added to request.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
/// <exception cref="CloudException">
/// Thrown when the operation returned an invalid status code
/// </exception>
/// <return>
/// A response object containing the response body and response headers.
/// </return>
public async Task <AzureOperationHeaderResponse <LROsCustomHeaderPostAsyncRetrySucceededHeaders> > BeginPostAsyncRetrySucceededWithHttpMessagesAsync(Product product = default(Product), Dictionary <string, List <string> > customHeaders = null, CancellationToken cancellationToken = default(CancellationToken))
{
// Tracing
bool _shouldTrace = ServiceClientTracing.IsEnabled;
string _invocationId = null;
if (_shouldTrace)
{
_invocationId = ServiceClientTracing.NextInvocationId.ToString();
Dictionary <string, object> tracingParameters = new Dictionary <string, object>();
tracingParameters.Add("product", product);
tracingParameters.Add("cancellationToken", cancellationToken);
ServiceClientTracing.Enter(_invocationId, this, "BeginPostAsyncRetrySucceeded", tracingParameters);
}
// Construct URL
var _baseUrl = Client.BaseUri.AbsoluteUri;
var _url = new System.Uri(new System.Uri(_baseUrl + (_baseUrl.EndsWith("/") ? "" : "/")), "lro/customheader/postasync/retry/succeeded").ToString();
List <string> _queryParameters = new List <string>();
if (_queryParameters.Count > 0)
{
_url += (_url.Contains("?") ? "&" : "?") + string.Join("&", _queryParameters);
}
// Create HTTP transport objects
var _httpRequest = new HttpRequestMessage();
HttpResponseMessage _httpResponse = null;
_httpRequest.Method = new HttpMethod("POST");
_httpRequest.RequestUri = new System.Uri(_url);
// Set Headers
if (Client.GenerateClientRequestId != null && Client.GenerateClientRequestId.Value)
{
_httpRequest.Headers.TryAddWithoutValidation("x-ms-client-request-id", System.Guid.NewGuid().ToString());
}
if (Client.AcceptLanguage != null)
{
if (_httpRequest.Headers.Contains("accept-language"))
{
_httpRequest.Headers.Remove("accept-language");
}
_httpRequest.Headers.TryAddWithoutValidation("accept-language", Client.AcceptLanguage);
}
if (customHeaders != null)
{
foreach (var _header in customHeaders)
{
if (_httpRequest.Headers.Contains(_header.Key))
{
_httpRequest.Headers.Remove(_header.Key);
}
_httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
}
}
// Serialize Request
string _requestContent = null;
if (product != null)
{
_requestContent = Microsoft.Rest.Serialization.SafeJsonConvert.SerializeObject(product, Client.SerializationSettings);
_httpRequest.Content = new StringContent(_requestContent, System.Text.Encoding.UTF8);
_httpRequest.Content.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json; charset=utf-8");
}
// Set Credentials
if (Client.Credentials != null)
{
cancellationToken.ThrowIfCancellationRequested();
await Client.Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
}
// Send Request
if (_shouldTrace)
{
ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
}
cancellationToken.ThrowIfCancellationRequested();
_httpResponse = await Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
if (_shouldTrace)
{
ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
}
HttpStatusCode _statusCode = _httpResponse.StatusCode;
cancellationToken.ThrowIfCancellationRequested();
string _responseContent = null;
if ((int)_statusCode != 202)
{
var ex = new CloudException(string.Format("Operation returned an invalid status code '{0}'", _statusCode));
try
{
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
CloudError _errorBody = Microsoft.Rest.Serialization.SafeJsonConvert.DeserializeObject <CloudError>(_responseContent, Client.DeserializationSettings);
if (_errorBody != null)
{
ex = new CloudException(_errorBody.Message);
ex.Body = _errorBody;
}
}
catch (JsonException)
{
// Ignore the exception
}
ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
if (_httpResponse.Headers.Contains("x-ms-request-id"))
{
ex.RequestId = _httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault();
}
if (_shouldTrace)
{
ServiceClientTracing.Error(_invocationId, ex);
}
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw ex;
}
// Create Result
var _result = new AzureOperationHeaderResponse <LROsCustomHeaderPostAsyncRetrySucceededHeaders>();
_result.Request = _httpRequest;
_result.Response = _httpResponse;
if (_httpResponse.Headers.Contains("x-ms-request-id"))
{
_result.RequestId = _httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault();
}
try
{
_result.Headers = _httpResponse.GetHeadersAsJson().ToObject <LROsCustomHeaderPostAsyncRetrySucceededHeaders>(JsonSerializer.Create(Client.DeserializationSettings));
}
catch (JsonException ex)
{
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw new SerializationException("Unable to deserialize the headers.", _httpResponse.GetHeadersAsJson().ToString(), ex);
}
if (_shouldTrace)
{
ServiceClientTracing.Exit(_invocationId, _result);
}
return(_result);
}
public JsonSerialization(JsonSerializerSettings settings)
{
_serializer = JsonSerializer.Create(settings);
}
public CustomJsonCodec(JsonSerializerSettings serializerSettings, IReadableConfiguration configuration)
{
_serializerSettings = serializerSettings;
_serializer = JsonSerializer.Create(_serializerSettings);
_configuration = configuration;
}
public JsonSerializer CreateSerializer()
{
return(JsonSerializer.Create(this));
}
public static JsonSerializer GetJsonSerializer()
{
return(JsonSerializer.Create(GetJsonSerializerSettings()));
}
private JsonSerializer InitializeSerializer()
{
var settings = InitializeSettings();
return(JsonSerializer.Create(settings));
}
public static string GetMetadata(Content content)
{
//collects regular fields
var types1 = new List <type>();
var i = 0;
foreach (var contentType in ContentType.GetContentTypes())
{
if (contentType.Name.ToLower().Contains("fieldsetting"))
{
continue;
}
var c = "ct" + i;
var ct = new type {
n = contentType.Name, d = SNSR.GetString(contentType.DisplayName), c = c
};
types1.Add(ct);
var fields = new List <field>();
var fieldSettings = contentType.FieldSettings.Where(s => s.IndexingInfo.IsInIndex);
foreach (var fieldSetting in fieldSettings)
{
if (fieldSetting.Name == "FieldSettingContents" || fieldSetting.Name == "AllFieldSettingContents")
{
continue;
}
var displayName = String.IsNullOrEmpty(fieldSetting.DisplayName) ? fieldSetting.Name : SNSR.GetString(fieldSetting.DisplayName);
var fieldType = fieldSetting.ShortName;
var choiceField = fieldSetting as ChoiceFieldSetting;
if (choiceField != null)
{
var opts = choiceField.Options.Select(o => new option {
n = o.Text, v = o.Value, e = o.Enabled, s = o.Selected
}).ToArray();
fields.Add(new field {
n = fieldSetting.Name, d = displayName, t = "choice", c = c, q = opts
});
}
else if (fieldType != "Binary")
{
fields.Add(new field {
n = fieldSetting.Name, d = displayName, t = fieldType, c = c
});
}
}
ct.f = fields.OrderBy(x => x.d).ToArray();
i++;
}
types1 = types1.OrderBy(x => x.d).ToList();
//collect aspect fields
var types2 = new List <type>();
var aspects = ContentQuery.Query("TypeIs:Aspect .AUTOFILTERS:OFF").Nodes;
i = 0;
foreach (Aspect aspect in aspects)
{
var c = "a" + i;
var at = new type {
n = aspect.Name, d = SNSR.GetString(aspect.DisplayName), c = c
};
types2.Add(at);
var fields = new List <field>();
foreach (var field in aspect.FieldSettings)
{
if (field != null)
{
var displayName = String.IsNullOrEmpty(field.DisplayName) ? field.Name : SNSR.GetString(field.DisplayName);
var fieldType = field.ShortName;
if (fieldType != "BinaryData")
{
fields.Add(new field {
n = field.Name, d = displayName, t = fieldType, c = c
});
}
}
}
at.f = fields.OrderBy(x => x.d).ToArray();
i++;
}
types2 = types2.OrderBy(x => x.d).ToList();
var sb = new StringBuilder();
var settings = new JsonSerializerSettings {
Formatting = Formatting.None, NullValueHandling = NullValueHandling.Ignore
};
var serializer = JsonSerializer.Create(settings);
using (var writer = new StringWriter(sb))
serializer.Serialize(writer, new[] { types1, types2 });
return(sb.ToString());
}
public void Export(ExportParameters exportParameters)
{
// Check input text is valid
var scaleFactorFloat = 1.0f;
string scaleFactor = exportParameters.scaleFactor;
try
{
scaleFactor = scaleFactor.Replace(".", System.Globalization.NumberFormatInfo.CurrentInfo.NumberDecimalSeparator);
scaleFactor = scaleFactor.Replace(",", System.Globalization.NumberFormatInfo.CurrentInfo.NumberDecimalSeparator);
scaleFactorFloat = float.Parse(scaleFactor);
}
catch
{
RaiseError("Scale factor is not a valid number.");
return;
}
long quality = 0L;
string txtQuality = exportParameters.txtQuality;
try
{
quality = long.Parse(txtQuality);
if (quality < 0 || quality > 100)
{
throw new Exception();
}
}
catch
{
RaiseError("Quality is not a valid number. It should be an integer between 0 and 100.");
RaiseError("This parameter set the quality of jpg compression.");
return;
}
this.exportParameters = exportParameters;
var gameConversionManger = Loader.Global.ConversionManager;
gameConversionManger.CoordSystem = Autodesk.Max.IGameConversionManager.CoordSystem.D3d;
var gameScene = Loader.Global.IGameInterface;
gameScene.InitialiseIGame(false);
gameScene.SetStaticFrame(0);
MaxSceneFileName = gameScene.SceneFileName;
IsCancelled = false;
RaiseMessage("Exportation started", Color.Blue);
ReportProgressChanged(0);
string outputDirectory = Path.GetDirectoryName(exportParameters.outputPath);
string outputFileName = Path.GetFileName(exportParameters.outputPath);
// Check directory exists
if (!Directory.Exists(outputDirectory))
{
RaiseError("Exportation stopped: Output folder does not exist");
ReportProgressChanged(100);
return;
}
var outputBabylonDirectory = outputDirectory;
// Force output file extension to be babylon
outputFileName = Path.ChangeExtension(outputFileName, "babylon");
var babylonScene = new BabylonScene(outputBabylonDirectory);
var rawScene = Loader.Core.RootNode;
var watch = new Stopwatch();
watch.Start();
string outputFormat = exportParameters.outputFormat;
isBabylonExported = outputFormat == "babylon" || outputFormat == "binary babylon";
// Save scene
if (exportParameters.autoSave3dsMaxFile)
{
RaiseMessage("Saving 3ds max file");
var forceSave = Loader.Core.FileSave;
callerForm?.BringToFront();
}
// Producer
babylonScene.producer = new BabylonProducer
{
name = "3dsmax",
#if MAX2018
version = "2018",
#elif MAX2017
version = "2017",
#else
version = Loader.Core.ProductVersion.ToString(),
#endif
exporter_version = exporterVersion,
file = outputFileName
};
// Global
babylonScene.autoClear = true;
babylonScene.clearColor = Loader.Core.GetBackGround(0, Tools.Forever).ToArray();
babylonScene.ambientColor = Loader.Core.GetAmbient(0, Tools.Forever).ToArray();
babylonScene.gravity = rawScene.GetVector3Property("babylonjs_gravity");
ExportQuaternionsInsteadOfEulers = rawScene.GetBoolProperty("babylonjs_exportquaternions", 1);
if (Loader.Core.UseEnvironmentMap && Loader.Core.EnvironmentMap != null)
{
// Environment texture
var environmentMap = Loader.Core.EnvironmentMap;
// Copy image file to output if necessary
var babylonTexture = ExportEnvironmnentTexture(environmentMap, babylonScene);
if (babylonTexture != null)
{
babylonScene.environmentTexture = babylonTexture.name;
// Skybox
babylonScene.createDefaultSkybox = rawScene.GetBoolProperty("babylonjs_createDefaultSkybox");
babylonScene.skyboxBlurLevel = rawScene.GetFloatProperty("babylonjs_skyboxBlurLevel");
}
}
// Sounds
var soundName = rawScene.GetStringProperty("babylonjs_sound_filename", "");
if (!string.IsNullOrEmpty(soundName))
{
var filename = Path.GetFileName(soundName);
var globalSound = new BabylonSound
{
autoplay = rawScene.GetBoolProperty("babylonjs_sound_autoplay", 1),
loop = rawScene.GetBoolProperty("babylonjs_sound_loop", 1),
name = filename
};
babylonScene.SoundsList.Add(globalSound);
if (isBabylonExported)
{
try
{
File.Copy(soundName, Path.Combine(babylonScene.OutputPath, filename), true);
}
catch
{
}
}
}
// Root nodes
RaiseMessage("Exporting nodes");
HashSet <IIGameNode> maxRootNodes = getRootNodes(gameScene);
var progressionStep = 80.0f / maxRootNodes.Count;
var progression = 10.0f;
ReportProgressChanged((int)progression);
referencedMaterials.Clear();
// Reseting is optionnal. It makes each morph target manager export starts from id = 0.
BabylonMorphTargetManager.Reset();
foreach (var maxRootNode in maxRootNodes)
{
exportNodeRec(maxRootNode, babylonScene, gameScene);
progression += progressionStep;
ReportProgressChanged((int)progression);
CheckCancelled();
}
;
RaiseMessage(string.Format("Total meshes: {0}", babylonScene.MeshesList.Count), Color.Gray, 1);
// Main camera
BabylonCamera babylonMainCamera = null;
ICameraObject maxMainCameraObject = null;
if (babylonMainCamera == null && babylonScene.CamerasList.Count > 0)
{
// Set first camera as main one
babylonMainCamera = babylonScene.CamerasList[0];
babylonScene.activeCameraID = babylonMainCamera.id;
RaiseMessage("Active camera set to " + babylonMainCamera.name, Color.Green, 1, true);
// Retreive camera node with same GUID
var maxCameraNodesAsTab = gameScene.GetIGameNodeByType(Autodesk.Max.IGameObject.ObjectTypes.Camera);
var maxCameraNodes = TabToList(maxCameraNodesAsTab);
var maxMainCameraNode = maxCameraNodes.Find(_camera => _camera.MaxNode.GetGuid().ToString() == babylonMainCamera.id);
maxMainCameraObject = (maxMainCameraNode.MaxNode.ObjectRef as ICameraObject);
}
if (babylonMainCamera == null)
{
RaiseWarning("No camera defined", 1);
}
else
{
RaiseMessage(string.Format("Total cameras: {0}", babylonScene.CamerasList.Count), Color.Gray, 1);
}
// Default light
if (babylonScene.LightsList.Count == 0)
{
RaiseWarning("No light defined", 1);
RaiseWarning("A default hemispheric light was added for your convenience", 1);
ExportDefaultLight(babylonScene);
}
else
{
RaiseMessage(string.Format("Total lights: {0}", babylonScene.LightsList.Count), Color.Gray, 1);
}
if (scaleFactorFloat != 1.0f)
{
RaiseMessage("A root node is added for scaling", 1);
// Create root node for scaling
BabylonMesh rootNode = new BabylonMesh {
name = "root", id = Guid.NewGuid().ToString()
};
rootNode.isDummy = true;
float rootNodeScale = 1.0f / scaleFactorFloat;
rootNode.scaling = new float[3] {
rootNodeScale, rootNodeScale, rootNodeScale
};
// Update all top nodes
var babylonNodes = new List <BabylonNode>();
babylonNodes.AddRange(babylonScene.MeshesList);
babylonNodes.AddRange(babylonScene.CamerasList);
babylonNodes.AddRange(babylonScene.LightsList);
foreach (BabylonNode babylonNode in babylonNodes)
{
if (babylonNode.parentId == null)
{
babylonNode.parentId = rootNode.id;
}
}
// Store root node
babylonScene.MeshesList.Add(rootNode);
}
// Materials
RaiseMessage("Exporting materials");
var matsToExport = referencedMaterials.ToArray(); // Snapshot because multimaterials can export new materials
foreach (var mat in matsToExport)
{
ExportMaterial(mat, babylonScene);
CheckCancelled();
}
RaiseMessage(string.Format("Total: {0}", babylonScene.MaterialsList.Count + babylonScene.MultiMaterialsList.Count), Color.Gray, 1);
// Fog
for (var index = 0; index < Loader.Core.NumAtmospheric; index++)
{
var atmospheric = Loader.Core.GetAtmospheric(index);
if (atmospheric.Active(0) && atmospheric.ClassName == "Fog")
{
var fog = atmospheric as IStdFog;
RaiseMessage("Exporting fog");
if (fog != null)
{
babylonScene.fogColor = fog.GetColor(0).ToArray();
babylonScene.fogMode = 3;
}
if (babylonMainCamera != null)
{
babylonScene.fogStart = maxMainCameraObject.GetEnvRange(0, 0, Tools.Forever);
babylonScene.fogEnd = maxMainCameraObject.GetEnvRange(0, 1, Tools.Forever);
}
}
}
// Skeletons
if (skins.Count > 0)
{
RaiseMessage("Exporting skeletons");
foreach (var skin in skins)
{
ExportSkin(skin, babylonScene);
}
}
// Output
babylonScene.Prepare(false, false);
if (isBabylonExported)
{
RaiseMessage("Saving to output file");
var outputFile = Path.Combine(outputBabylonDirectory, outputFileName);
var jsonSerializer = JsonSerializer.Create(new JsonSerializerSettings());
var sb = new StringBuilder();
var sw = new StringWriter(sb, CultureInfo.InvariantCulture);
using (var jsonWriter = new JsonTextWriterOptimized(sw))
{
jsonWriter.Formatting = Formatting.None;
jsonSerializer.Serialize(jsonWriter, babylonScene);
}
File.WriteAllText(outputFile, sb.ToString());
if (exportParameters.generateManifest)
{
File.WriteAllText(outputFile + ".manifest",
"{\r\n\"version\" : 1,\r\n\"enableSceneOffline\" : true,\r\n\"enableTexturesOffline\" : true\r\n}");
}
// Binary
if (outputFormat == "binary babylon")
{
RaiseMessage("Generating binary files");
BabylonFileConverter.BinaryConverter.Convert(outputFile, outputBabylonDirectory + "\\Binary",
message => RaiseMessage(message, 1),
error => RaiseError(error, 1));
}
}
ReportProgressChanged(100);
// Export glTF
if (outputFormat == "gltf" || outputFormat == "glb")
{
bool generateBinary = outputFormat == "glb";
ExportGltf(babylonScene, outputDirectory, outputFileName, generateBinary);
}
watch.Stop();
RaiseMessage(string.Format("Exportation done in {0:0.00}s", watch.ElapsedMilliseconds / 1000.0), Color.Blue);
}
static XmlMessageSerializer()
{
_xmlSerializer = new Lazy <JsonSerializer>(() => JsonSerializer.Create(XmlSerializerSettings));
}
/// <summary>
/// Initializes a new instance of the <see cref="NewtonsoftJsonHubProtocol"/> class.
/// </summary>
/// <param name="options">The options used to initialize the protocol.</param>
public NewtonsoftJsonHubProtocol(IOptions <NewtonsoftJsonHubProtocolOptions> options)
{
PayloadSerializer = JsonSerializer.Create(options.Value.PayloadSerializerSettings);
}
public string Execute(string controllerName, string methodName, JArray parameters, string credential)
{
object service = null;
// credential is set here, this is because we need a workaround for AWS or other API Gateway/Load Balancer that can do proper CORS response
RequestCredential requestCredential = null;
if (!services.TryResolve(out requestCredential))
{
throw new CompactServerException(500, $"Type '{nameof(RequestCredential)}' was not registered in the AutoFac services");
}
requestCredential.Value = credential;
if (!serviceTypes.ContainsKey(controllerName))
{
throw new ServiceNotFoundException($"Controller '{controllerName}' was not found in the CompactServerTypes instance. Please make sure you have added it to the registered instance of CompactServerTypes in AutoFac.");
}
if (!services.TryResolve(serviceTypes[controllerName], out service))
{
throw new ServiceNotFoundException($"Controller '{serviceTypes[controllerName].FullName}' was not found in the AutoFac services. Please make sure you have registered it as Type in AutoFac.");
}
Type serviceType = serviceTypes[controllerName];
var methodInfo = serviceType.GetMethod(methodName);
if (methodInfo == null)
{
throw new ServiceNotFoundException($"Method '{methodName}' was not found in Controller '{serviceTypes[controllerName].FullName}'.");
}
if (!methodInfo.GetCustomAttributes <RpcAttribute>().Any())
{
throw new ServiceNotFoundException($"Method '{methodName}' of '{serviceTypes[controllerName].FullName}' does not have {nameof(RpcAttribute)}. You need to add {nameof(RpcAttribute)} to service method.");
}
var filters = methodInfo.GetCustomAttributes(true).Where(attr => IActionFilterType.IsAssignableFrom(attr.GetType())).ToList();
foreach (var filter in filters)
{
if (!(filter as IActionFilter).CanInvoke(services))
{
throw new CompactServerException(401, $"The credential did not pass the authentication check by {filter.GetType().FullName}.");
}
}
// parameters are not needed until here
var serializer = JsonSerializer.Create(jsonSerializerSettings);
int index = 0;
List <object> parameterList = new List <object>();
foreach (var parameter in methodInfo.GetParameters())
{
parameterList.Add(parameters[index].ToObject(parameter.ParameterType, serializer));
index += 1;
}
// the response could be a task
var response = methodInfo.Invoke(service, parameterList.ToArray());
if (response == null)
{
return(JsonConvert.SerializeObject(response, jsonSerializerSettings));
}
else
{
var responseType = response.GetType();
if (responseType.IsGenericType && TaskType.IsAssignableFrom(responseType))
{
// process the task await
var awaiter = responseType.GetMethod(nameof(Task <object> .GetAwaiter)).Invoke(response, EmptyParameters);
var awaiterType = awaiter.GetType();
var result = awaiterType.GetMethod(nameof(TaskAwaiter <object> .GetResult)).Invoke(awaiter, EmptyParameters);
return(JsonConvert.SerializeObject(result, jsonSerializerSettings));
}
else
{
return(JsonConvert.SerializeObject(response, jsonSerializerSettings));
}
}
}
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory, IApplicationLifetime appLifetime)
{
app.UseGlobalErrorHandler();
app.UseOptions();
var settings = ApplicationContainer.Resolve <MtFrontSettings>();
if (settings.CorsSettings.Enabled)
{
app.UseCors(builder =>
{
builder.WithOrigins(settings.CorsSettings.AllowOrigins)
.WithHeaders(settings.CorsSettings.AllowHeaders)
.WithMethods(settings.CorsSettings.AllowMethods);
if (settings.CorsSettings.AllowCredentials)
{
builder.AllowCredentials();
}
});
}
var host = ApplicationContainer.Resolve <IWampHost>();
var realm = ApplicationContainer.Resolve <IWampHostedRealm>();
var realmMetaService = realm.HostMetaApiService();
app.UseAuthentication();
app.UseMvc(routes =>
{
routes.MapRoute(name: "Default", template: "{controller=Home}/{action=Index}/{id?}");
});
app.UseSwagger();
app.UseSwaggerUi();
app.UseStaticFiles();
app.Map("/ws", builder =>
{
builder.UseWebSockets(new WebSocketOptions {
KeepAliveInterval = TimeSpan.FromMinutes(1)
});
var jsonSettings =
new JsonSerializerSettings()
{
Converters = SerializerSettings.GetDefaultConverters()
};
var jsonSerializer = JsonSerializer.Create(jsonSettings);
host.RegisterTransport(new AspNetCoreWebSocketTransport(builder),
new JTokenJsonBinding(jsonSerializer),
new JTokenMsgpackBinding(jsonSerializer));
});
appLifetime.ApplicationStopped.Register(() => ApplicationContainer.Dispose());
var application = app.ApplicationServices.GetService <Application>();
appLifetime.ApplicationStarted.Register(() =>
{
if (!string.IsNullOrEmpty(settings.ApplicationInsightsKey))
{
Microsoft.ApplicationInsights.Extensibility.TelemetryConfiguration.Active.InstrumentationKey =
settings.ApplicationInsightsKey;
}
application.StartAsync().Wait();
LogLocator.CommonLog?.WriteMonitorAsync("", "", settings.Env + " Started");
});
appLifetime.ApplicationStopping.Register(() =>
{
LogLocator.CommonLog?.WriteMonitorAsync("", "", settings.Env + " Terminating");
realmMetaService.Dispose();
application.Stop();
}
);
host.Open();
}
private static JsonSerializer CreateSerializer()
{
var settings = new JsonSerializerSettings();
return(JsonSerializer.Create(settings));
}
// LUCENENET specific - copy method not used
/// <summary>
/// Executes the replication task.
/// </summary>
/// <exception cref="InvalidOperationException">required parameters are missing</exception>
public virtual void Perform(IReplicationRequest request, IReplicationResponse response)
{
string[] pathElements = GetPathElements(request);
if (pathElements.Length != 2)
{
throw ServletException.Create("invalid path, must contain shard ID and action, e.g. */s1/update");
}
if (!Enum.TryParse(pathElements[ACTION_IDX], true, out ReplicationAction action))
{
throw ServletException.Create("Unsupported action provided: " + pathElements[ACTION_IDX]);
}
if (!replicators.TryGetValue(pathElements[SHARD_IDX], out IReplicator replicator))
{
throw ServletException.Create("unrecognized shard ID " + pathElements[SHARD_IDX]);
}
// SOLR-8933 Don't close this stream.
try
{
switch (action)
{
case ReplicationAction.OBTAIN:
string sessionId = ExtractRequestParam(request, REPLICATE_SESSION_ID_PARAM);
string fileName = ExtractRequestParam(request, REPLICATE_FILENAME_PARAM);
string source = ExtractRequestParam(request, REPLICATE_SOURCE_PARAM);
using (Stream stream = replicator.ObtainFile(sessionId, source, fileName))
stream.CopyTo(response.Body);
break;
case ReplicationAction.RELEASE:
replicator.Release(ExtractRequestParam(request, REPLICATE_SESSION_ID_PARAM));
break;
case ReplicationAction.UPDATE:
string currentVersion = request.QueryParam(REPLICATE_VERSION_PARAM);
SessionToken token = replicator.CheckForUpdate(currentVersion);
if (token is null)
{
response.Body.Write(new byte[] { 0 }, 0, 1); // marker for null token
}
else
{
response.Body.Write(new byte[] { 1 }, 0, 1);
token.Serialize(new DataOutputStream(response.Body));
}
break;
// LUCENENET specific:
default:
if (Debugging.AssertsEnabled)
{
Debugging.Assert(false, "Invalid ReplicationAction specified");
}
break;
}
}
catch (Exception e)
{
response.StatusCode = (int)HttpStatusCode.InternalServerError; // propagate the failure
try
{
TextWriter writer = new StreamWriter(response.Body);
JsonSerializer serializer = JsonSerializer.Create(JSON_SERIALIZER_SETTINGS);
serializer.Serialize(writer, e, e.GetType());
}
catch (Exception e2) when(e2.IsException())
{
throw new IOException("Could not serialize", e2);
}
}
finally
{
response.Flush();
}
}
public PowerShellPolicyFixture()
{
systemWideConfigDirectory = Utils.DefaultPowerShellAppBase;
currentUserConfigDirectory = Platform.ConfigDirectory;
if (!Directory.Exists(currentUserConfigDirectory))
{
// Create the CurrentUser config directory if it doesn't exist
Directory.CreateDirectory(currentUserConfigDirectory);
}
systemWideConfigFile = Path.Combine(systemWideConfigDirectory, ConfigFileName);
currentUserConfigFile = Path.Combine(currentUserConfigDirectory, ConfigFileName);
if (File.Exists(systemWideConfigFile))
{
systemWideConfigBackupFile = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
File.Move(systemWideConfigFile, systemWideConfigBackupFile);
}
if (File.Exists(currentUserConfigFile))
{
currentUserConfigBackupFile = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
File.Move(currentUserConfigFile, currentUserConfigBackupFile);
}
var settings = new JsonSerializerSettings()
{
TypeNameHandling = TypeNameHandling.None,
MaxDepth = 10,
Formatting = Formatting.Indented,
NullValueHandling = NullValueHandling.Ignore
};
serializer = JsonSerializer.Create(settings);
systemWidePolicies = new PowerShellPolicies()
{
ScriptExecution = new ScriptExecution()
{
ExecutionPolicy = "RemoteSigned", EnableScripts = true
},
ScriptBlockLogging = new ScriptBlockLogging()
{
EnableScriptBlockInvocationLogging = true, EnableScriptBlockLogging = false
},
ModuleLogging = new ModuleLogging()
{
EnableModuleLogging = false, ModuleNames = new string[] { "PSReadline", "PowerShellGet" }
},
ProtectedEventLogging = new ProtectedEventLogging()
{
EnableProtectedEventLogging = false, EncryptionCertificate = new string[] { "Joe" }
},
Transcription = new Transcription()
{
EnableInvocationHeader = true, EnableTranscripting = true, OutputDirectory = @"c:\tmp"
},
UpdatableHelp = new UpdatableHelp()
{
DefaultSourcePath = @"f:\temp"
},
ConsoleSessionConfiguration = new ConsoleSessionConfiguration()
{
EnableConsoleSessionConfiguration = true, ConsoleSessionConfigurationName = "name"
}
};
currentUserPolicies = new PowerShellPolicies()
{
ScriptExecution = new ScriptExecution()
{
ExecutionPolicy = "RemoteSigned"
},
ScriptBlockLogging = new ScriptBlockLogging()
{
EnableScriptBlockLogging = false
},
ModuleLogging = new ModuleLogging()
{
EnableModuleLogging = false
},
ProtectedEventLogging = new ProtectedEventLogging()
{
EncryptionCertificate = new string[] { "Joe" }
}
};
// Set the test hook to disable policy caching
originalTestHookValue = InternalTestHooks.BypassGroupPolicyCaching;
InternalTestHooks.BypassGroupPolicyCaching = true;
}
private object DeserializeComplexType(JContainer obj, Type targetType)
{
return(obj.ToObject(targetType, JsonSerializer.Create(_jsonApiContext.Options.SerializerSettings)));
}
public RpcResponse DeserializeResponse(JToken token, Func <RpcId, Type> resultTypeResolver = null)
{
RpcId id = null;
JToken idToken = token[JsonRpcContants.IdPropertyName];
if (idToken == null)
{
throw new RpcClientParseException("Unable to parse request id.");
}
switch (idToken.Type)
{
case JTokenType.Null:
break;
case JTokenType.Integer:
id = new RpcId(idToken.Value <long>());
break;
case JTokenType.String:
case JTokenType.Guid:
id = new RpcId(idToken.Value <string>());
break;
default:
throw new RpcClientParseException("Unable to parse rpc id as string or integer.");
}
JToken errorToken = token[JsonRpcContants.ErrorPropertyName];
if (errorToken != null && errorToken.HasValues)
{
int code = errorToken.Value <int>(JsonRpcContants.ErrorCodePropertyName);
string message = errorToken.Value <string>(JsonRpcContants.ErrorMessagePropertyName);
JToken dataToken = errorToken[JsonRpcContants.ErrorDataPropertyName];
object data = null;
if (dataToken != null)
{
data = this.errorDataSerializer.Deserialize(code, dataToken.ToString());
}
var error = new RpcError(code, message, data: data);
return(new RpcResponse(id, error));
}
else
{
Type resultType = resultTypeResolver?.Invoke(id);
object result;
if (resultType == null)
{
//dont deserialize
//TODO tostring?
result = token[JsonRpcContants.ResultPropertyName].ToString();
}
else if (this.jsonSerializerSettings == null)
{
result = token[JsonRpcContants.ResultPropertyName].ToObject(resultType);
}
else
{
//TODo cache serializer?
JsonSerializer serializer = JsonSerializer.Create(this.jsonSerializerSettings);
result = token[JsonRpcContants.ResultPropertyName].ToObject(resultType, serializer);
}
return(new RpcResponse(id, result));
}
}
