private static string[] GetHklmSubKeyNames(string keyName, ITraceWriter trace)
{
RegistryKey key = Registry.LocalMachine.OpenSubKey(keyName);
if (key == null)
{
trace?.Info($"Key name '{keyName}' is null.");
return(new string[0]);
}
try
{
string[] subKeyNames = key.GetSubKeyNames() ?? new string[0];
trace?.Info($"Key name '{keyName}' contains sub keys:");
foreach (string subKeyName in subKeyNames)
{
trace?.Info($" '{subKeyName}'");
}
return(subKeyNames);
}
finally
{
key.Dispose();
}
}
public HttpResponseMessage Post([FromBody] UserRegistrationDTO value)
{
if (!ModelState.IsValid)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
try
{
var success = userService.Add(value);
if (success)
{
var okMessage = $"Succesfully created user: {value.Email}.";
tracer.Info(Request, ControllerContext.ControllerDescriptor.ControllerType.FullName, okMessage);
return(Request.CreateResponse(HttpStatusCode.OK, okMessage));
}
}
catch (EntityException e)
{
tracer.Error(Request, ControllerContext.ControllerDescriptor.ControllerType.FullName, e);
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, e));
}
const string message = "Incorrect request syntax.";
tracer.Warn(Request, ControllerContext.ControllerDescriptor.ControllerType.FullName, message);
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, message));
}
public IHttpActionResult Login(LoginData loginData)
{
_tracer.Info(Request, ControllerContext.ControllerDescriptor.ControllerType.FullName, "CognitoToken Get called.");
_tracer.Info(Request, ControllerContext.ControllerDescriptor.ControllerType.FullName, $"loginData username = {loginData.Username}");
_tracer.Info(Request, ControllerContext.ControllerDescriptor.ControllerType.FullName, $"loginData password = {loginData.Password}");
_tracer.Info(Request, ControllerContext.ControllerDescriptor.ControllerType.FullName, $"loginData authflow = {loginData.AuthFlow}");
var userFoundInUserPool =
AmazonCognitoHelper.GetAllUserPoolUsers().Any(u => u.Username == loginData.Username);
var password = loginData.Password;
var newPassword = Constants.NewPassword;
if (!userFoundInUserPool)
{
password = Constants.TemporaryPassword;
newPassword = loginData.Password;
AmazonCognitoHelper.CreateUser(loginData.Username);
}
var user = loginData.AuthFlow == nameof(AuthFlowType.CUSTOM_AUTH) ? AmazonCognitoHelper.ValidateUser(loginData.Username) :
loginData.AuthFlow == nameof(AuthFlowType.USER_SRP_AUTH) ? AmazonCognitoHelper.ValidateUser(loginData.Username, password, newPassword) :
throw new AuthenticationException($"Unrecognized auth flow {loginData.AuthFlow}");
return(Json(new
{
token = user.SessionTokens.IdToken
}));
}
/// <summary>
/// <see cref="IQueueListener.StartListening(string, MethodInfo)"/>
/// </summary>
public void StartListening(string queueName, MethodInfo queueTriggerMethod)
{
if (string.IsNullOrEmpty(queueName))
{
throw new ArgumentException("queueName must not be null or empty");
}
if (queueTriggerMethod == null)
{
throw new ArgumentNullException(nameof(queueTriggerMethod));
}
if (IsStopping)
{
_traceWriter.Info($"Cannot start listening to queue {queueName} as the listener is stopping");
return;
}
Task.Factory.StartNew(async() =>
{
if (_cancellationToken.IsCancellationRequested)
{
throw new InvalidOperationException($"Cannot start listening to queue {queueName} as the listener is stopping");
}
_traceWriter.Info($"Start Listening on queue '{queueName}'");
try
{
bool pollQueue = true;
while (pollQueue)
{
if (_cancellationToken.IsCancellationRequested)
{
pollQueue = false;
continue;
}
var messagesInQueue = true;
while (messagesInQueue)
{
messagesInQueue = await ProcessQueueNextBatchAsync(queueName, queueTriggerMethod);
}
if (!_cancellationToken.IsCancellationRequested)
{
Thread.Sleep(_queuePollIntervalSeconds * 1000);
}
}
}
catch (Exception ex)
{
_traceWriter.Error($"Caught an unhandled exception while attempting to process items from queue '{queueName}'", ex);
}
}, _cancellationToken);
}
// GET api/SearchBeer
public async Task <List <Beer> > Get(string keyword)
{
tracer.Info(string.Format("Search beer call with keyword {0}", keyword));
var rv = new List <Beer>();
bool needSave = false;
if (!BreweryDBHelper.InsureBreweryDbIsInitialized(settings, tracer))
{
return(rv);
}
try
{
var results = await new BreweryDB.BreweryDBClient().SearchForBeer(keyword);
if (results != null && results.Any())
{
tracer.Info(string.Format("Found {0} beers", results.Count()));
var context = new BeerDrinkinContext();
foreach (var r in results)
{
//check if we already have beer in db
var beer = context.Beers.FirstOrDefault(f => f.BreweryDbId == r.Id);
if (beer == null)
{
tracer.Info(string.Format("Beer {0} wasn't logged yet", r.Name));
needSave = true;
try
{
beer = r.ToBeerItem();
context.Beers.Add(beer);
}
catch (Exception ex)
{
tracer.Error(string.Format("Exception creating beer: {0}", ex.Message));
}
}
rv.Add(beer);
}
}
}
catch (Exception ex)
{
tracer.Error(ex.Message);
}
finally
{
if (needSave)
{
await context.SaveChangesAsync();
}
}
return(rv);
}
private void LogOutput(string data)
{
if (string.IsNullOrWhiteSpace(data))
{
return;
}
OnDataOutput?.Invoke(new OutputEventArgs(data));
_trace?.Info(data);
}
/// <summary>
/// Submits the change through Entity Framework while logging any exceptions
/// and produce appropriate <see cref="HttpResponseMessage"/> instances.
/// </summary>
/// <returns>A <see cref="Task"/> representing the operation.</returns>
public static async Task <int> SubmitChangesAsync(DbContext context, HttpRequestMessage request, Func <DbUpdateConcurrencyException, object> getOriginalValue)
{
HttpConfiguration config = request.GetConfiguration();
ITraceWriter traceWriter = config.Services.GetTraceWriter();
try
{
int result = await context.SaveChangesAsync();
return(result);
}
catch (DbEntityValidationException ex)
{
string validationDescription = EntityUtils.GetValidationDescription(ex);
string validationError = EFResources.DomainManager_ValidationError.FormatForUser(validationDescription);
traceWriter.Debug(validationError, request, LogCategories.TableControllers);
HttpResponseMessage invalid = request.CreateErrorResponse(HttpStatusCode.BadRequest, validationError, ex);
throw new HttpResponseException(invalid);
}
catch (DbUpdateConcurrencyException ex)
{
string conflictError = EFResources.DomainManager_ChangeConflict.FormatForUser(ex.Message);
traceWriter.Info(conflictError, request, LogCategories.TableControllers);
var content = getOriginalValue != null?getOriginalValue(ex) : conflictError;
HttpStatusCode statusCode = GetConflictStatusCode(request);
HttpResponseMessage conflict = request.CreateResponse(statusCode, content);
throw new HttpResponseException(conflict);
}
catch (DbUpdateException ex)
{
HttpResponseMessage error;
Exception baseEx = ex.GetBaseException();
SqlException sqlException = baseEx as SqlException;
if (sqlException != null && sqlException.Number == SqlUniqueConstraintViolationError)
{
string message = CommonResources.DomainManager_Conflict.FormatForUser(sqlException.Message);
error = request.CreateErrorResponse(HttpStatusCode.Conflict, message);
traceWriter.Info(message, request, LogCategories.TableControllers);
}
else
{
string message = EFResources.DomainManager_InvalidOperation.FormatForUser(baseEx.Message);
error = request.CreateErrorResponse(HttpStatusCode.BadRequest, message);
traceWriter.Error(message, request, LogCategories.TableControllers);
}
throw new HttpResponseException(error);
}
}
public HttpResponseMessage PostUserTaskMessage(int userTaskId, [FromBody] MessageDTO newMessage)
{
try
{
if (!ModelState.IsValid)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
newMessage.UserTaskId = userTaskId;
var currentId = userIdentityService.GetUserId();
newMessage.SenderId = currentId;
var success = messageService.SendMessage(newMessage);
if (success)
{
var message = $"Succesfully created message with id = {newMessage.Id} by user with id = {newMessage.SenderId}";
tracer.Info(Request, ControllerContext.ControllerDescriptor.ControllerType.FullName, message);
return(Request.CreateResponse(HttpStatusCode.OK, "Succesfully created message"));
}
tracer.Warn(Request, ControllerContext.ControllerDescriptor.ControllerType.FullName, "Error occured on message creating");
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Creation error."));
}
catch (EntityException e)
{
tracer.Error(Request, ControllerContext.ControllerDescriptor.ControllerType.FullName, e);
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, e));
}
}
private static object GetHklmValue(string keyName, string valueName, ITraceWriter trace)
{
keyName = $@"HKEY_LOCAL_MACHINE\{keyName}";
object value = Registry.GetValue(keyName, valueName, defaultValue: null);
if (object.ReferenceEquals(value, null))
{
trace?.Info($"Key name '{keyName}', value name '{valueName}' is null.");
return(null);
}
trace?.Info($"Key name '{keyName}', value name '{valueName}': '{value}'");
return(value);
}
// INode entry point.
public Boolean EvaluateBoolean(ITraceWriter trace, Object state)
{
if (Container != null)
{
throw new NotSupportedException($"Expected {nameof(INode)}.{nameof(EvaluateBoolean)} to be called on root node only.");
}
var context = new EvaluationContext(trace, state);
trace.Info($"Evaluating: {ConvertToExpression()}");
Boolean result = EvaluateBoolean(context);
trace.Info($"{ConvertToRealizedExpression(context)} => {result}");
return(result);
}
public static bool Test(Version minVersion, ITraceWriter trace)
{
ArgUtil.NotNull(minVersion, nameof(minVersion));
InitVersions(trace);
trace?.Info($"Testing for min NET Framework version: '{minVersion}'");
return(_versions.Any(x => x >= minVersion));
}
/// <summary>
/// Logs to the TraceWriter, if available.
/// </summary>
protected void Log(System.Web.Http.Tracing.TraceLevel level, string methodName, string msg)
{
msg = "Method: " + methodName + ". " + msg;//prepend method name
ITraceWriter tracewriter = Configuration.Services.GetTraceWriter();
if (tracewriter != null)
{
switch (level)
{
case System.Web.Http.Tracing.TraceLevel.Error:
tracewriter.Error(Request, "", msg);
break;
case System.Web.Http.Tracing.TraceLevel.Warn:
tracewriter.Warn(Request, "", msg);
break;
case System.Web.Http.Tracing.TraceLevel.Info:
tracewriter.Info(Request, "", msg);
break;
default:
tracewriter.Debug(Request, "", msg);
break;
}
}
}
public HttpResponseMessage Get(int id)
{
var employee = list.FirstOrDefault(e => e.Id == id);
if (employee == null)
{
var response = Request.CreateResponse(HttpStatusCode.NotFound, new HttpError(Resources.Messages.NotFound));
return(response);
}
if (traceWriter != null)
{
traceWriter.Info(Request, "EmployeesController", String.Format("Getting employee {0}", id));
traceWriter.Trace(Request, "System.Web.Http.Controllers", System.Web.Http.Tracing.TraceLevel.Info, (traceRecord) =>
{
traceRecord.Message = String.Format("Getting employee {0}", id);
traceRecord.Operation = "Get(int)";
traceRecord.Operator = "EmployeeController";
});
}
var blackListed = "";
var allowedFormatters = Configuration.Formatters.Where(f => !f.SupportedMediaTypes.Any(m => m.MediaType.Equals(blackListed, StringComparison.OrdinalIgnoreCase)));
var result = Configuration.Services.GetContentNegotiator().Negotiate(typeof(Employee), Request, allowedFormatters);
return(new HttpResponseMessage()
{
Content = new ObjectContent <Employee>(employee, result.Formatter, result.MediaType)
});
}
// GET api/SearchBeer
public async Task <List <Brewery> > Get(string keyword)
{
tracer.Info(string.Format("Search brewery call with keyword {0}", keyword));
var rv = new List <Brewery>();
if (!BreweryDBHelper.InsureBreweryDbIsInitialized(settings, tracer))
{
return(rv);
}
try
{
var results = await new BreweryDB.BreweryDBClient().SearchForBeer(keyword);
if (results != null && results.Any())
{
foreach (var r in results)
{
var brewery = new Brewery
{
Id = r.Id,
Name = r.Name,
Description = r.Description
};
rv.Add(brewery);
}
}
}
catch (Exception ex)
{
tracer.Error(ex.Message);
}
return(rv);
}
// GET api/employees/12345
//public Employee Get(int id)
//{
// return list.First(e => e.Id == id);
//}
public Employee Get(int id)
{
var employee = list.FirstOrDefault(e => e.Id == id);
if (traceWriter != null)
{
traceWriter.Info(Request, "EmployeesController", String.Format("Getting employee {0}", id));
}
if (traceWriter != null)
{
traceWriter.Trace(
Request, "System.Web.Http.Controllers", System.Web.Http.Tracing.TraceLevel.Info,
(traceRecord) =>
{
traceRecord.Message =
String.Format("Getting employee {0}", id);
traceRecord.Operation = "Get(int)";
traceRecord.Operator = "EmployeeController";
});
}
return(employee);
}
public async Task <User> GetUser(string token)
{
try
{
var key = "User_" + token;
var user = this._cache.Get(key) as User;
if (user != null)
{
return(user);
}
var client = new HttpClient {
BaseAddress = new Uri(ConfigurationManager.AppSettings["SonatribeApi"])
};
client.DefaultRequestHeaders.TryAddWithoutValidation("x-access-token", token);
_tracer.Info(null, "CachingUserDao", "fetching with code {0}", token);
var responseString = await client.GetStringAsync("users/me");
user = JsonConvert.DeserializeObject <User>(responseString);
return(user);
}
catch (Exception exc)
{
_tracer.Error(null, "CachingUserDao", "exception: ", exc);
throw;
}
}
// GET api/values
public string Get()
{
MobileAppSettingsDictionary settings = this.Configuration.GetMobileAppSettingsProvider().GetMobileAppSettings();
ITraceWriter traceWriter = this.Configuration.Services.GetTraceWriter();
string host = settings.HostName ?? "localhost";
string greeting = "Hello from " + host;
EabcMobileAppContext context = new EabcMobileAppContext();
try
{
var item = context.PrayerRequestModels.FirstOrDefault();
if (item != null)
{
greeting = item.Request;
}
}
catch (Exception e)
{
greeting = e.ToString();
}
traceWriter.Info(greeting);
return(greeting);
}
public string Metadata()
{
_tracer.Info(Request, ControllerContext.ControllerDescriptor.ControllerType.FullName, "Obteniendo metadata del repositorio");
string metadata;
try
{
metadata = _context.Metadata;
}
catch (Exception ex)
{
new LogEvent(ex).Raise();
_tracer.Error(Request, ControllerContext.ControllerDescriptor.ControllerType.FullName, ex);
throw;
}
return(metadata);
}
private TestHostContext Setup([CallerMemberName] string name = "")
{
_issues = new List <Tuple <DTWebApi.Issue, string> >();
var hostContext = new TestHostContext(this, name);
// Trace
_trace = hostContext.GetTrace();
// Directory for test data
var workDirectory = hostContext.GetDirectory(WellKnownDirectory.Work);
ArgUtil.NotNullOrEmpty(workDirectory, nameof(workDirectory));
Directory.CreateDirectory(workDirectory);
_rootDirectory = Path.Combine(workDirectory, nameof(SetEnvFileCommandL0));
Directory.CreateDirectory(_rootDirectory);
// Execution context
_executionContext = new Mock <IExecutionContext>();
_executionContext.Setup(x => x.Global)
.Returns(new GlobalContext
{
EnvironmentVariables = new Dictionary <string, string>(VarUtil.EnvironmentVariableKeyComparer),
WriteDebug = true,
});
_executionContext.Setup(x => x.AddIssue(It.IsAny <DTWebApi.Issue>(), It.IsAny <string>()))
.Callback((DTWebApi.Issue issue, string logMessage) =>
{
_issues.Add(new Tuple <DTWebApi.Issue, string>(issue, logMessage));
var message = !string.IsNullOrEmpty(logMessage) ? logMessage : issue.Message;
_trace.Info($"Issue '{issue.Type}': {message}");
});
_executionContext.Setup(x => x.Write(It.IsAny <string>(), It.IsAny <string>()))
.Callback((string tag, string message) =>
{
_trace.Info($"{tag}{message}");
});
// SetEnvFileCommand
_setEnvFileCommand = new SetEnvFileCommand();
_setEnvFileCommand.Initialize(hostContext);
return(hostContext);
}
// GET api/UPC
public List <Beer> Get(string upc)
{
tracer.Info($"Searching for Barcode number: {upc}");
ITraceWriter traceWriter = this.Configuration.Services.GetTraceWriter();
BeerDrinkinContext context = new BeerDrinkinContext();
var beers = context.Beers.Where(x => x.UPC == upc).ToList();
return(beers);
}
// GET api/values
public string Get()
{
MobileAppSettingsDictionary settings = this.Configuration.GetMobileAppSettingsProvider().GetMobileAppSettings();
ITraceWriter traceWriter = this.Configuration.Services.GetTraceWriter();
traceWriter.Info("Hello from " + settings.Name);
return("Hello World!");
}
protected override void Initialize(HttpControllerContext controllerContext)
{
base.Initialize(controllerContext);
SuperfishBackendContext context = new SuperfishBackendContext();
DomainManager = new EntityDomainManager <TodoItem>(context, Request);
ITraceWriter traceWriter = this.Configuration.Services.GetTraceWriter();
traceWriter.Info("Hello, World");
}
// GET api/values
public string Get()
{
MobileAppSettingsDictionary settings = this.Configuration.GetMobileAppSettingsProvider().GetMobileAppSettings();
ITraceWriter traceWriter = this.Configuration.Services.GetTraceWriter();
string host = settings.HostName ?? "localhost";
string greeting = "Hello from " + host;
traceWriter.Info(greeting);
return(greeting);
}
/// <summary>
/// Get NOPV details for given BBL.
/// </summary>
/// <param name="id">BBL</param>
/// <returns></returns>
public IHttpActionResult Get(string id)
{
_logger.Info(Request, this.ControllerContext.ControllerDescriptor.ControllerType.FullName, "Get called.");
NOPVData data = _nopvData.GetDetails(id);
if (data == null)
{
return(Content(HttpStatusCode.NotFound, "BBL not found"));
}
return(Ok(data));
}
public void Log(ThrottleLogEntry entry)
{
traceWriter?.Info(
entry.Request,
"WebApiThrottle",
"{0} Request {1} from {2} has been throttled (blocked), quota {3}/{4} exceeded by {5}",
entry.LogDate,
entry.RequestId,
entry.ClientIp,
entry.RateLimit,
entry.RateLimitPeriod,
entry.TotalRequests);
}
// GET api/PopularBeers
public async Task <List <Beer> > Get(double longitude, double latitude)
{
//Find the current country of the user
string bingKey;
if (!(settings.TryGetValue("BING_API_KEY", out bingKey)))
{
tracer.Error("Could not retrieve Bing API key.");
bingKey = "AlPB42X199-b_n7tnHPSNM15E4cvLv18hfj4upv3irWgSFHx5GplSaOS3wpggCox";
}
tracer.Info($"Bing API Key{bingKey}");
return(null);
}
public HttpResponseMessage Post(int planTaskId, CommentDTO comment)
{
if (!ModelState.IsValid)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
try
{
if (commentService.AddCommentToPlanTask(planTaskId, comment))
{
var log = $"Succesfully created comment with id = {comment.Id} by user id = {comment.CreatorId}";
tracer.Info(Request, ControllerContext.ControllerDescriptor.ControllerType.FullName, log);
return(Request.CreateResponse(HttpStatusCode.OK, "Comment succesfully created"));
}
tracer.Warn(Request, ControllerContext.ControllerDescriptor.ControllerType.FullName, "Error occured on creating comment");
return(Request.CreateErrorResponse(HttpStatusCode.NoContent, "Not possibly to add comment: task in this plan does not exist"));
}
catch (EntityException e)
{
tracer.Error(Request, ControllerContext.ControllerDescriptor.ControllerType.FullName, e);
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "Internal creation error"));
}
}
public void Output(string message)
{
lock (_stdoutLock)
{
if (_trace == null)
{
Console.WriteLine(message);
}
else
{
_trace.Info(message);
}
}
}
public HttpResponseMessage Post([FromBody] PlanDTO value)
{
try
{
var success = planService.Add(value);
if (success)
{
var log = $"Succesfully created plan {value.Name} with id = {value.Id} by user with id = {value.CreatorId}";
tracer.Info(Request, ControllerContext.ControllerDescriptor.ControllerType.FullName, log);
var okMessage = $"Succesfully created plan: {value.Name}";
return(Request.CreateResponse(HttpStatusCode.OK, okMessage));
}
}
catch (EntityException e)
{
tracer.Error(Request, ControllerContext.ControllerDescriptor.ControllerType.FullName, e);
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, e));
}
tracer.Warn(Request, ControllerContext.ControllerDescriptor.ControllerType.FullName, "Error occured on creating plan");
const string message = "Incorrect request syntax.";
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, message));
}
public void Output(string message)
{
ArgUtil.NotNull(message, nameof(message));
lock (_stdoutLock)
{
if (_trace == null)
{
Console.WriteLine(message);
}
else
{
_trace.Info(message);
}
}
}
public static bool InsureBreweryDbIsInitialized(MobileAppSettingsDictionary appSettings, ITraceWriter logger)
{
settings = appSettings;
tracer = logger;
if (string.IsNullOrEmpty(BreweryDB.BreweryDBClient.ApplicationKey))
{
string apiKey;
// Try to get the BreweryDB API key app settings.
if (!(settings.TryGetValue("BREWERYDB_API_KEY", out apiKey)))
{
tracer.Error("Could not retrieve BreweryDB API key.");
return false;
}
tracer.Info($"BreweryDB API Key {apiKey}");
BreweryDB.BreweryDBClient.Initialize(apiKey);
}
return true;
}
