/// <summary>
/// Update a given tenant
/// </summary>
/// <param name="tenantId">Tenant ID</param>
/// <param name="name">Tenant name</param>
/// <param name="description">Tenant description</param>
/// <param name="azureSasTokens">Tenant Azure SAS token</param>
/// <returns>Cogniac.Tenant</returns>
public Tenant UpdateTenant
(
string tenantId,
string name = null,
string description = null,
string azureSasTokens = null
)
{
if (string.IsNullOrEmpty(tenantId))
{
throw new ArgumentException("message", nameof(tenantId));
}
Dictionary <string, object> dict = new Dictionary <string, object> {
};
dict.AddIfNotNull("name", name);
dict.AddIfNotNull("description", description);
dict.AddIfNotNull("azure_sas_tokens", azureSasTokens);
string data = Helpers.MapToQueryString(dict);
var request = new RestRequest(Method.POST)
{
AlwaysMultipartFormData = true
};
string fullUrl = $"{_urlPrefix}/tenants/{tenantId}?{data}";
var response = ExecuteRequest(fullUrl, request);
if (response.IsSuccessful && (response.StatusCode == HttpStatusCode.OK))
{
return(Tenant.FromJson(response.Content));
}
else
{
throw new WebException(message: "Network error while updating tenant: " + response.Content);
}
}
/// <summary>
/// Search the Cogniac system for a specific media file
/// </summary>
/// <param name="fileName">The name of the file</param>
/// <param name="externalMediaId">The external media ID of the file</param>
/// <param name="md5">The MD5 hash of the file</param>
/// <returns>Cogniac.Media Array</returns>
public Media[] SearchMedia(string fileName = null, string externalMediaId = null, string md5 = null)
{
// Check that at least ONE term is supplied
if ((String.IsNullOrEmpty(fileName)) &&
(String.IsNullOrEmpty(externalMediaId)) &&
(String.IsNullOrEmpty(md5)))
{
throw new ArgumentException("Provide one argument when invoking the 'SearchMedia' method.");
}
else
{
// Perform the search here
Dictionary <string, object> dict = new Dictionary <string, object> {
};
dict.AddIfNotNull("filename", fileName);
dict.AddIfNotNull("external_media_id", externalMediaId);
dict.AddIfNotNull("md5", md5);
string data = Helpers.MapToQueryString(dict);
string fullUrl = $"{_urlPrefix}/media/all/search?{data}";
var request = new RestRequest(Method.GET);
var response = ExecuteRequest(fullUrl, request);
if (response.IsSuccessful && (response.StatusCode == HttpStatusCode.OK))
{
return(Media.FromJson(response.Content).MediaList);
}
else
{
throw new WebException(message: "Network error while searching for media: " + response.Content);
}
}
}
public async Task <NewsFeedResponse> GetFeedsAsync(bool?includeFavIcons = null, bool?isFlatStructure = null, bool?updateCounts = null, CancellationToken cancellationToken = default(CancellationToken))
{
var options = new Dictionary <string, string>();
options.AddIfNotNull("include_favicons", includeFavIcons);
options.AddIfNotNull("flat", isFlatStructure);
options.AddIfNotNull("update_counts", updateCounts);
var response = await GetResponse <NewsFeedResponse>("reader", "feeds", options, cancellationToken);
return(response.Response);
}
public async Task <StoriesResponse> GetStoriesAsync(int feedId, int?pageIndex = null, bool invertOrder = false, bool filterReadStories = false, bool includeHiddenStories = false, CancellationToken cancellationToken = default(CancellationToken))
{
var options = new Dictionary <string, string>();
options.AddIfNotNull("page", pageIndex);
options.AddIfNotNull("order", invertOrder ? "oldest" : null);
options.AddIfNotNull("read_filter", filterReadStories ? "unread" : null);
options.AddIfNotNull("include_hidden", includeHiddenStories);
var response = await GetResponse <StoriesResponse>("reader/feed", feedId.ToString(), options, cancellationToken);
return(response.Response);
}
static void Main(string[] args)
{
var dictionary = new Dictionary <string, object>( );
dictionary.AddIfNotNull("not-added", null);
dictionary.AddIfNotNull("added", "true");
foreach (var item in dictionary)
{
Console.WriteLine(item.Key);
}
Console.Read( );
}
public Dictionary <string, object> ToDictionary()
{
Dictionary <string, object> orderDictionary = new Dictionary <string, object>();
orderDictionary.AddIfNotNull(quantityFieldName, Quantity);
return(orderDictionary);
}
public async Task <SignupResponse> SignupAsync(string username, string emailAddress, string password = "", CancellationToken cancellationToken = default(CancellationToken))
{
if (string.IsNullOrEmpty(username))
{
throw new ArgumentNullException(nameof(username), "username must be provided");
}
if (string.IsNullOrEmpty(emailAddress))
{
throw new ArgumentNullException(nameof(emailAddress), "email address must be provided");
}
var postData = new Dictionary <string, string>
{
{ "username", username },
{ "email", emailAddress }
};
postData.AddIfNotNull("password", password);
var response = await PostResponse <InternalLoginResponse>("api", "signup", postData, cancellationToken);
var loginResponse = response.Response;
return(new SignupResponse(loginResponse.Authenticated, response.NewsBlurCookie, loginResponse.UserId));
}
public CompetitionsResponse Competitions(int?year = null)
{
var parameters = new Dictionary <string, string>();
parameters.AddIfNotNull("season", year?.ToString());
return(GetPrivate("competitions", parameters.ToParameters(), new CompetitionsResponse().Parse));
}
/// <summary>
/// Update a option
/// </summary>
/// <param name="options">List option</param>
/// <param name="optionNestingType">Child or parent</param>
/// <param name="parentId">Parent id</param>
/// <param name="name">Name</param>
/// <param name="type">Type</param>
/// <param name="enabled">Enabled</param>
/// <param name="sort">Sort</param>
/// <returns>List option</returns>
public static PrivateApiResponse <List <OptionWriteResponse> > UpdateOptions(List <OptionWriteResponse> options, OptionNestingType optionNestingType = OptionNestingType.Parent, int parentId = 0, string name = "Test Option"
, int type = 0, int?enabled = null, int?sort = null)
{
var optionHandler = new OptionManager();
var optionRequestParameters = new Dictionary <string, object>()
{
["id"] = -1,
["parent_id"] = parentId,
["name"] = name,
["type"] = type,
};
optionRequestParameters.AddIfNotNull("enabled", enabled);
optionRequestParameters.AddIfNotNull("sort", sort);
var listOptions = new List <Dictionary <string, object> >();
if (OptionNestingType.Parent == optionNestingType)
{
foreach (var option in options)
{
optionRequestParameters["id"] = option.Id;
listOptions.Add(optionRequestParameters);
}
}
else
{
optionRequestParameters["id"] = options.FirstOrDefault().Id;
var listChildOptions = new List <Dictionary <string, object> >();
foreach (var optionChilds in options.Select(item => item.Children))
{
foreach (var child in optionChilds)
{
var childOptionParameters = new Dictionary <string, object>(optionRequestParameters);
childOptionParameters.Remove("parent_id");
childOptionParameters["id"] = child.Id;
listChildOptions.Add(childOptionParameters);
}
}
optionRequestParameters.Add("children", listChildOptions);
listOptions.Add(optionRequestParameters);
}
return(optionHandler.WriteOptions(listOptions));
}
public FixturesResponse Fixtures(int competitionId, int?periodInDays = null, FixturesPeriodType?periodType = null, int?matchDay = null)
{
var parameters = new Dictionary <string, string>();
parameters.AddIf(periodInDays != null && periodType != null, "timeFrame", $"{periodType?.GetDescription()}{periodInDays}");
parameters.AddIfNotNull("matchday", matchDay?.ToString());
return(GetPrivate($"competitions/{competitionId}/fixtures", parameters.ToParameters(), new FixturesResponse().Parse));
}
/// <summary>
/// Associates a given media file with an exiting subject
/// </summary>
/// <param name="mediaId">Media ID</param>
/// <param name="subjectUid">Subject UID</param>
/// <param name="forceFeedback">Fore feedback flag</param>
/// <param name="enableWaitResult">Enable wait flag</param>
/// <param name="probability">Association probability, only valid if consensus is null</param>
/// <param name="consensus">Consensus value</param>
/// <returns>Cogniac.CaptureId object</returns>
public CaptureId AssociateMediaToSubject(string mediaId, string subjectUid, bool forceFeedback = false, bool enableWaitResult = false,
double?probability = null, bool?consensus = null)
{
if (string.IsNullOrEmpty(mediaId) || string.IsNullOrEmpty(subjectUid))
{
throw new ArgumentException(message: "Provided media ID or subject UID are is or empty.");
}
else
{
Dictionary <string, object> dict = new Dictionary <string, object>
{
{ "media_id", mediaId },
{ "force_feedback", forceFeedback },
{ "enable_wait_result", enableWaitResult }
};
// Perform some logic for the probability
if (consensus == null)
{
if (probability == null)
{
probability = 0.99;
}
// Insert it into the API call
dict.AddIfNotNull("uncal_prob", probability);
}
else
{
dict.AddIfNotNull("consensus", consensus);
}
var request = new RestRequest(Method.POST);
string data = Helpers.MapToQueryString(dict);
IRestResponse response = ExecuteRequest($"{_urlPrefix}/subjects/{subjectUid}/media?{data}", request);
if ((response.StatusCode == HttpStatusCode.OK) && (response.IsSuccessful == true))
{
return(CaptureId.FromJson(response.Content));
}
else
{
throw new WebException(message: "Network error: " + response.Content);
}
}
}
/// <summary>
/// Create a option
/// </summary>
/// <param name="loop">Created number option</param>
/// <param name="optionNestingType">Child or parent</param>
/// <param name="id">Id</param>
/// <param name="parentId">Parent id</param>
/// <param name="name">Name</param>
/// <param name="type">Type</param>
/// <param name="enabled">Enabled</param>
/// <param name="sort">Sort</param>
/// <returns>List option</returns>
public static PrivateApiResponse <List <OptionWriteResponse> > CreateOptions(int numberOfOptions = 0, OptionNestingType optionNestingType = OptionNestingType.Parent, int id = -1, int parentId = 0
, string name = "Test Option", int type = 0, int?enabled = null, int?sort = null)
{
var optionHandler = new OptionManager();
var optionRequestParameters = new Dictionary <string, object>()
{
["id"] = id,
["parent_id"] = parentId,
["name"] = name,
["type"] = type,
};
optionRequestParameters.AddIfNotNull("enabled", enabled);
optionRequestParameters.AddIfNotNull("sort", sort);
var childOptionParameters = new Dictionary <string, object>(optionRequestParameters);
var listOptions = new List <Dictionary <string, object> >();
childOptionParameters.Remove("parent_id");
if (OptionNestingType.Parent == optionNestingType)
{
for (int i = 0; i <= numberOfOptions; i++)
{
listOptions.Add(optionRequestParameters);
}
}
else
{
var listChildOptions = new List <Dictionary <string, object> >();
for (int i = 0; i <= numberOfOptions; i++)
{
listChildOptions.Add(childOptionParameters);
}
optionRequestParameters.Add("children", listChildOptions);
listOptions.Add(optionRequestParameters);
}
return(optionHandler.WriteOptions(listOptions));
}
private IEnumerable <ApiEvent> ConvertEvent(Rank e)
{
var ranks = new Dictionary <string, int>();
ranks.AddIfNotNull(nameof(e.Combat), e.Combat);
ranks.AddIfNotNull(nameof(e.Cqc), e.Cqc);
ranks.AddIfNotNull(nameof(e.Empire), e.Empire);
ranks.AddIfNotNull(nameof(e.Explore), e.Explore);
ranks.AddIfNotNull(nameof(e.Federation), e.Federation);
ranks.AddIfNotNull(nameof(e.Trade), e.Trade);
foreach (var rank in ranks)
{
var @event = new ApiEvent("setCommanderRankPilot")
{
Timestamp = e.Timestamp,
EventData = new Dictionary <string, object>()
{
{ "rankName", rank.Key.ToLower() },
{ "rankValue", rank.Value }
}
};
yield return(@event);
}
}
private IEnumerable <ApiEvent> ConvertEvent(MissionCompleted e)
{
var data = new Dictionary <string, object>()
{
{ "missionGameID", e.MissionId },
{ "missionName", e.Name },
{ "donationCredits", e.Donation },
{ "rewardCredits", e.Reward },
};
data.AddIfNotNull("rewardCommodities", ConvertCommodityReward(e.CommodityReward));
data.AddIfNotNull("rewardMaterials", ConvertMaterialReward(e.MaterialsReward));
data.AddIfNotNull("minorfactionEffects", ConvertMissionFactionEffects(e.FactionEffects));
var @event = new ApiEvent("setCommanderMissionCompleted")
{
Timestamp = e.Timestamp,
EventData = data
};
yield return(@event);
if (e.MaterialsReward != null)
{
foreach (var cr in e.MaterialsReward)
{
@event = new ApiEvent("addCommanderInventoryMaterialsItem")
{
Timestamp = e.Timestamp,
EventData = new Dictionary <string, object>()
{
{ "itemName", cr.Name },
{ "itemCount", cr.Count }
}
};
yield return(@event);
}
}
}
public override async Task <HttpResponse <DataPaged <Video> > > ExecuteAsync(GetAllVideosRequest request,
CancellationToken cancellationToken = default)
{
var uri = string.Empty;
if (string.IsNullOrEmpty(request.UserId))
{
uri = $"videos";
}
else
{
if (request.UserId.ToLower().Equals(ServiceConstants.ME))
{
uri = $"{request.UserId}/videos";
}
else
{
uri = $"users/{request.UserId}/videos";
}
}
try
{
var query = new Dictionary <string, string>();
query.AddIfNotNull("page", request.Page?.ToString());
query.AddIfNotNull("per_page", request.PageSize?.ToString());
var response = await _httpService.HttpGetAsync <DataPaged <Video> >($"{uri}", query);
return(response);
}
catch (Exception exception)
{
_logger.LogError(exception);
return(HttpResponse <DataPaged <Video> > .FromException(exception.Message));
}
}
public Dictionary <string, object> ToDictionary()
{
Dictionary <string, object> orderDictionary = new Dictionary <string, object>();
// var itemIDs = GetIdFromNameIfPresent(Item, _ItemsLookup).ToArray();
orderDictionary.AddIfNotNull(NameKey, Name);
orderDictionary.Add(IncludedItemsKey, new List <string> {
ItemRecordId
});
// else if (itemIDs.Length > 0)
{
// orderDictionary.AddIfNotNull(IncludedItemsKey, itemIDs);
}
orderDictionary.AddIfNotNull(QuantityKey, Quantity);
orderDictionary.AddIfNotNull(PaidKey, Paid);
if (OrderID != null)
{
orderDictionary.Add(OrderIdKey, new List <string> {
OrderID
});
}
return(orderDictionary);
}
/// <summary>
/// Creates a subject in the Cogniac system
/// </summary>
/// <param name="name">Subject name</param>
/// <param name="description">Subject description</param>
/// <param name="publicRead">Public read flag</param>
/// <param name="publicWrite">Public write flag</param>
/// <returns>Cogniac.Subject object</returns>
public Subject CreateSubject
(
string name,
string description = null,
bool?publicRead = null,
bool?publicWrite = null
)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentException("message", nameof(name));
}
Dictionary <string, object> dict = new Dictionary <string, object>
{
{ "name", name }
};
dict.AddIfNotNull("description", description);
dict.AddIfNotNull("public_read", publicRead);
dict.AddIfNotNull("public_write", publicWrite);
string data = Helpers.MapToQueryString(dict);
var request = new RestRequest(Method.POST)
{
AlwaysMultipartFormData = true
};
string fullUrl = $"{_urlPrefix}/subjects?{data}";
var response = ExecuteRequest(fullUrl, request);
if (response.IsSuccessful && (response.StatusCode == HttpStatusCode.OK))
{
return(Subject.FromJson(response.Content));
}
else
{
throw new WebException(message: "Network error while creating subject: " + response.Content);
}
}
public override async Task <HttpResponse <UploadTicket> > ExecuteAsync(CancellationToken cancellationToken = default)
{
var uri = $"me/videos";
var query = new Dictionary <string, string>();
query.AddIfNotNull("type", UploadVideoType.STREAMING?.ToString());
try
{
var response = await _httpService.HttpPostByQueryAsync <UploadTicket>(uri, query);
return(response);
}
catch (Exception exception)
{
_logger.LogError(exception, "Details: uri, querytype {0}, {1}", uri, UploadVideoType.STREAMING?.ToString());
return(HttpResponse <UploadTicket> .FromException(exception.Message));
}
}
public Dictionary <string, object> ToDictionary()
{
var orderDictionary = new Dictionary <string, object>();
orderDictionary.AddIfNotNull(NameKey, Name.ToString());
orderDictionary.AddIfNotNull(DateKey, Date.ToString("d"));
orderDictionary.AddIfNotNull(ValueKey, Value);
orderDictionary.AddIfNotNull(QuantityKey, Quantity);
orderDictionary.AddIfNotNull(DeliveredToKey, DeliveredTo);
orderDictionary.AddIfNotNull(OrderIdKey, OrderId);
return(orderDictionary);
}
private IEnumerable <ApiEvent> ConvertEvent(MissionAccepted e)
{
var data = new Dictionary <string, object>()
{
{ "missionName", e.Name },
{ "missionGameID", e.MissionId },
{ "missionExpiry", e.Expiry },
{ "influenceGain", e.Influence },
{ "reputationGain", e.Reputation },
{ "starsystemNameOrigin", playerStateRecorder.GetPlayerSystem(e.Timestamp) },
{ "stationNameOrigin", playerStateRecorder.GetPlayerStation(e.Timestamp) },
{ "minorfactionNameOrigin", e.Faction },
{ "starsystemNameTarget", e.DestinationSystem },
{ "stationNameTarget", e.DestinationStation },
{ "minorfactionNameTarget", e.TargetFaction }
};
data.AddIfNotNull("commodityName", e.Commodity);
data.AddIfNotNull("commodityCount", e.Count);
data.AddIfNotNull("targetName", e.Target);
data.AddIfNotNull("targetType", e.TargetType);
data.AddIfNotNull("killCount", e.KillCount);
data.AddIfNotNull("passengerType", e.PassengerType);
data.AddIfNotNull("passengerCount", e.PassengerCount);
data.AddIfNotNull("passengerIsVIP", e.PassengerVIPs);
data.AddIfNotNull("passengerIsWanted", e.PassengerWanted);
var @event = new ApiEvent("addCommanderMission")
{
Timestamp = e.Timestamp,
EventData = data
};
yield return(@event);
}
public async Task <LoginResponse> LoginAsync(string username, string password, CancellationToken cancellation = default(CancellationToken))
{
if (string.IsNullOrEmpty(username))
{
throw new ArgumentNullException(nameof(username), "Username cannot be null or empty");
}
var postData = new Dictionary <string, string>
{
{ "username", username }
};
postData.AddIfNotNull("password", password);
var response = await PostResponse <InternalLoginResponse>("api", "login", postData, cancellation).ConfigureAwait(false);
var loginResponse = response.Response;
return(new LoginResponse(loginResponse.Authenticated, response.NewsBlurCookie, loginResponse.UserId));
}
/// <summary>
/// Creates an application in the Cogniac system
/// </summary>
/// <param name="name">Application name</param>
/// <param name="type">Application type</param>
/// <param name="description">Description of application</param>
/// <param name="inputSubjects">List of input subjects</param>
/// <param name="outputSubjects">List of output subjects</param>
/// <param name="releaseMetrics">Release metrics</param>
/// <param name="detectionThresholds">Detection thresholds</param>
/// <param name="detectionPostUrls">Detection post URL's</param>
/// <param name="gatewayPostUrls">Gateway post URL's</param>
/// <param name="active">Active flag</param>
/// <param name="requestedFeedbackPerHour">Requested feedback per hour value</param>
/// <param name="refreshFeedback">Refresh feedback flag</param>
/// <param name="appManagers">List of application managers</param>
/// <returns>Cogniac.Application object</returns>
public Application CreateApplication
(
string name,
string type,
string description = null,
string[] inputSubjects = null,
string[] outputSubjects = null,
string releaseMetrics = null,
Dictionary <string, string> detectionThresholds = null,
string[] detectionPostUrls = null,
string[] gatewayPostUrls = null,
bool active = false,
int?requestedFeedbackPerHour = null,
bool refreshFeedback = false,
string[] appManagers = null
)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentException("message", nameof(name));
}
if (string.IsNullOrEmpty(type))
{
throw new ArgumentException("message", nameof(type));
}
Dictionary <string, object> dict = new Dictionary <string, object>
{
{ "name", name },
{ "type", type },
};
dict.AddIfNotNull("description", description);
dict.AddIfNotNull("input_subjects", Helpers.FlattenStringArray(inputSubjects));
dict.AddIfNotNull("output_subjects", Helpers.FlattenStringArray(outputSubjects));
dict.AddIfNotNull("release_metrics", releaseMetrics);
dict.AddIfNotNull("detection_post_urls", Helpers.FlattenStringArray(detectionPostUrls));
dict.AddIfNotNull("gateway_post_urls", Helpers.FlattenStringArray(gatewayPostUrls));
dict.AddIfNotNull("active", active);
dict.AddIfNotNull("requested_feedback_per_hour", requestedFeedbackPerHour);
dict.AddIfNotNull("refresh_feedback", refreshFeedback);
dict.AddIfNotNull("app_managers", Helpers.FlattenStringArray(appManagers));
if (detectionThresholds != null)
{
dict.AddIfNotNull("detection_thresholds", detectionThresholds.ToJson());
}
string data = Helpers.MapToQueryString(dict);
var request = new RestRequest(Method.POST)
{
AlwaysMultipartFormData = true
};
string fullUrl = $"{_urlPrefix}/applications?{data}";
var response = ExecuteRequest(fullUrl, request);
if (response.IsSuccessful && (response.StatusCode == HttpStatusCode.OK))
{
return(Application.FromJson(response.Content));
}
else
{
throw new WebException(message: "Network error while creating application: " + response.Content);
}
}
private static Dictionary <string, string> GetOutputOptionsPairs(OutputOptions outputOptions)
{
var pairs = new Dictionary <string, string>();
var basic = (BasicOutputOptions)outputOptions;
pairs.AddIfNotNull("Author", basic.Author);
pairs.AddIfNotNull("Comments", basic.Comments);
pairs.AddIfNotNull("Company", basic.Company);
pairs.AddIfNotNull("Keywords", basic.Keywords);
pairs.AddIfNotNull("Subject", basic.Subject);
pairs.AddIfNotNull("Title", basic.Title);
if (outputOptions is PdfOutputOptions)
{
var pdf = (PdfOutputOptions)outputOptions;
pairs.AddIfNotNull("EmbedFonts", pdf.EmbedFonts);
pairs.AddIfNotNull("PdfA", pdf.PdfA);
pairs.AddIfNotNull("TaggedPdf", pdf.TaggedPdf);
pairs.AddIfNotNull("KeepFillablePdf", pdf.KeepFillablePdf);
pairs.AddIfNotNull("TruncateFields", pdf.TruncateFields);
pairs.AddIfNotNull("Permissions", pdf.Permissions);
pairs.AddIfNotNull("OwnerPassword", pdf.OwnerPassword);
pairs.AddIfNotNull("UserPassword", pdf.UserPassword);
}
else if (outputOptions is HtmlOutputOptions)
{
pairs.AddIfNotNull("Encoding", ((HtmlOutputOptions)outputOptions).Encoding);
}
else if (outputOptions is TextOutputOptions)
{
pairs.AddIfNotNull("Encoding", ((TextOutputOptions)outputOptions).Encoding);
}
return(pairs);
}
private static Dictionary <string, string> GetProperties(LogInfo logInfo)
{
var prop = new Dictionary <string, string>();
prop.AddIfNotNull("TypeKey", logInfo.LogTypeKey);
prop.AddIfNotNull("ConfigID", logInfo.LogConfigID);
prop.AddIfNotNull("FileID", logInfo.LogFileID);
prop.AddIfNotNull("GUID", logInfo.LogGUID);
prop.AddIfNotNull("PortalName", logInfo.LogPortalName);
prop.AddIfNotNull("ServerName", logInfo.LogServerName);
prop.AddIfNotNull("UserName", logInfo.LogUserName);
prop.AddIfNotNull("CreateDate", logInfo.LogCreateDate.ToString(CultureInfo.InvariantCulture));
prop.AddIfNotNull("EventID", logInfo.LogEventID.ToString());
prop.AddIfNotNull("PortalID", logInfo.LogPortalID.ToString());
prop.AddIfNotNull("UserID", logInfo.LogUserID.ToString());
prop.AddIfNotNull("Exception.Message", logInfo.Exception.Message);
prop.AddIfNotNull("Exception.Source", logInfo.Exception.Source);
prop.AddIfNotNull("Exception.StackTrace", logInfo.Exception.StackTrace);
prop.AddIfNotNull("Exception.InnerMessage", logInfo.Exception.InnerMessage);
prop.AddIfNotNull("Exception.InnerStackTrace", logInfo.Exception.InnerStackTrace);
if (logInfo.LogProperties != null)
{
prop.AddIfNotNull("Summary", logInfo.LogProperties.Summary);
foreach (LogDetailInfo logProperty in logInfo.LogProperties)
{
prop.AddIfNotNull(logProperty.PropertyName, logProperty.PropertyValue);
}
}
return(prop);
}
// See https://developers.facebook.com/docs/graph-api/reference/user/events
public async Task<string> PublishEvent(IdentityUser user, FacebookEvent ev)
{
var accessToken = GetAccessToken(user);
var client = new FacebookClient(accessToken);
var eventdata = new Dictionary<string, object>();
eventdata.AddIfNotNull("name", ev.Name);
eventdata.AddIfNotNull("description", ev.Description);
eventdata.AddIfNotNull("start_time", "2014-04-30"); // Use DateTimeConverter To.... here
eventdata.AddIfNotNull("location", "Lincoln, NE");
eventdata.AddIfNotNull("privacy_type", "OPEN");
var result = await client.PostTaskAsync(string.Format("me/events"), eventdata);
var settings = new JsonSerializerSettings
{
MissingMemberHandling = MissingMemberHandling.Ignore,
NullValueHandling = NullValueHandling.Ignore
};
var id = JsonConvert.DeserializeObject<FacebookIdentity>(result.ToString(), settings);
Log.InfoFormat("Published a Facebook event. UserId={0} CreatedId={1} Name={2}", user.Id, id.Id, ev.Name);
return id.Id;
}
public Dictionary <string, object> ToDictionary()
{
Dictionary <string, object> orderDictionary = new Dictionary <string, object>();
string[] printOperatorID = GetIdFromNameIfPresent(PrintOperator, _NameLookup)?.ToArray();
string[] shipperID = GetIdFromNameIfPresent(Shipper, _NameLookup)?.ToArray();
string[] channelID = GetIdFromNameIfPresent(Channel, _ChannelLookup)?.ToArray();
orderDictionary.AddIfNotNull(OrderIDKey, OrderID.ToString());
orderDictionary.AddIfNotNull(DescriptionKey, Description);
orderDictionary.AddIfNotNull(NotesKey, Notes);
orderDictionary.AddIfNotNull(OrderNoteKey, OrderNote);
orderDictionary.AddIfNotNull(CustomerKey, CustomerEmail);
orderDictionary.AddIfNotNull(TotalPaymentKey, TotalPrice);
orderDictionary.AddIfNotNull(ActualShippingKey, ShippingCost);
orderDictionary.AddIfNotNull(SalesTaxKey, SalesTax);
orderDictionary.AddIfNotNull(ShippingChargeKey, ShippingCharge);
orderDictionary.AddIfNotNull(MaterialCostKey, MaterialCost);
if (DueDate.Year > 2010)
{
orderDictionary.AddIfNotNull(DueDateKey, DueDate.ToString("d"));
}
if (ShipDate.Year > 2010)
{
orderDictionary.AddIfNotNull(ShippedDateKey, ShipDate.ToString("d"));
}
orderDictionary.AddIfNotNull(RushKey, Rush);
orderDictionary.AddIfNotNull(PrintOperatorKey, printOperatorID);
orderDictionary.AddIfNotNull(ShipperKey, shipperID);
orderDictionary.AddIfNotNull(ShipperPayKey, ShipperPay);
orderDictionary.AddIfNotNull(ChannelKey, channelID);
orderDictionary.AddIfNotNull(AsanaTaskIDKey, AsanaTaskID);
orderDictionary.AddIfNotNull(OptinSentTypeKey, OptinSentType);
orderDictionary.AddIfNotNull(ValueOfInventoryKey, ValueOfInventory);
orderDictionary.AddIfNotNull(AmountRefundedKey, AmountRefunded);
return(orderDictionary);
}
public Dictionary <string, object> ToDictionary()
{
Dictionary <string, object> orderDictionary = new Dictionary <string, object>();
string[] printOperatorID = GetIdFromNameIfPresent(PrintOperator, _NameLookup)?.ToArray();
string[] DestinationLocationID = GetIdFromNameIfPresent(DestinationLocation, _NameLookup)?.ToArray();
string[] shipperID = GetIdFromNameIfPresent(Shipper, _NameLookup)?.ToArray();
if (!string.IsNullOrEmpty(IncludedComponentId))
{
orderDictionary.AddIfNotNull(IncludedComponentsKey, new string[] { IncludedComponentId });
}
orderDictionary.AddIfNotNull(OrderIDKey, OrderID);
orderDictionary.AddIfNotNull(StageKey, Stage);
orderDictionary.AddIfNotNull(OrderValueKey, OrderValue);
orderDictionary.AddIfNotNull(DescriptionKey, Description);
orderDictionary.AddIfNotNull(NotesKey, Notes);
orderDictionary.AddIfNotNull(OrderNoteKey, OrderNote);
orderDictionary.AddIfNotNull(PersonalizationKey, Personalization);
if (DueDate.Year > 2010)
{
orderDictionary.AddIfNotNull(DueDateKey, DueDate.ToString("d"));
}
if (ShipDate.Year > 2010)
{
orderDictionary.AddIfNotNull(ShippedDateKey, ShipDate.ToString("d"));
}
orderDictionary.AddIfNotNull(RushKey, Priority);
orderDictionary.AddIfNotNull(CancelledKey, Cancelled);
orderDictionary.AddIfNotNull(InventoryRequestKey, IsInventoryRequest);
orderDictionary.AddIfNotNull(OrderTypeKey, OrderType);
orderDictionary.AddIfNotNull(PrintOperatorKey, printOperatorID);
orderDictionary.AddIfNotNull(DestinationLocationKey, DestinationLocationID);
orderDictionary.AddIfNotNull(ShipperKey, shipperID);
orderDictionary.AddIfNotNull(ChannelKey, Channel);
orderDictionary.AddIfNotNull(OrderURLKey, OrderURL);
orderDictionary.AddIfNotNull(DesignerURLKey, DesignerURL);
if (RequestedQuantity > 0)
{
orderDictionary.AddIfNotNull(RequestedQuantityKey, RequestedQuantity);
}
return(orderDictionary);
}
public static Dictionary<string, string> GetOutputOptionsPairs(OutputOptions outputOptions)
{
var pairs = new Dictionary<string, string>();
var basic = (BasicOutputOptions)outputOptions;
pairs.AddIfNotNull("Author", basic.Author);
pairs.AddIfNotNull("Comments", basic.Comments);
pairs.AddIfNotNull("Company", basic.Company);
pairs.AddIfNotNull("Keywords", basic.Keywords);
pairs.AddIfNotNull("Subject", basic.Subject);
pairs.AddIfNotNull("Title", basic.Title);
if (outputOptions is PdfOutputOptions)
{
var pdf = (PdfOutputOptions)outputOptions;
pairs.AddIfNotNull("EmbedFonts", pdf.EmbedFonts);
pairs.AddIfNotNull("PdfA", pdf.PdfA);
pairs.AddIfNotNull("TaggedPdf", pdf.TaggedPdf);
pairs.AddIfNotNull("KeepFillablePdf", pdf.KeepFillablePdf);
pairs.AddIfNotNull("TruncateFields", pdf.TruncateFields);
pairs.AddIfNotNull("Permissions", pdf.Permissions);
pairs.AddIfNotNull("OwnerPassword", pdf.OwnerPassword);
pairs.AddIfNotNull("UserPassword", pdf.UserPassword);
}
else if (outputOptions is HtmlOutputOptions)
{
pairs.AddIfNotNull("Encoding", ((HtmlOutputOptions)outputOptions).Encoding);
}
else if (outputOptions is TextOutputOptions)
{
pairs.AddIfNotNull("Encoding", ((TextOutputOptions)outputOptions).Encoding);
}
return pairs;
}
