private static async Task <List <Sample> > GetSamples(HttpClient client, List <Site> sites, List <Data> datas)
{
Console.Write("GetSamples started...");
List <Sample> ret = new List <Sample>();
foreach (var data in datas)
{
// SITE
List <Site> sites1 = sites.Where(x => x.Name.ToUpper() == data.PointName.Trim().ToUpper()).ToList();
if (sites1.Count != 1)
{
throw new Exception($"(sites1.Count = {sites1.Count }) for [{sites1[0].Name}] & [{sites1[1].Name}]");
}
int siteId = sites1[0].Id;
Sample sample = new Sample {
SiteId = siteId, SampleNum = data.SampleNum
};
List <Sample> samples = await SamplesAPI.GetByFilterAsync(client, sample);
if (samples == null || samples.Count == 0)
{
sample.Id = await SamplesAPI.CreateAsync(client, sample);
}
else if (samples.Count == 1)
{
sample = samples[0];
}
else
{
throw new Exception($"More than one device with name [{data}]");
}
ret.Add(sample);
}
Console.WriteLine($" and endeded. {ret.Count} items generated.");
return(ret);
}
public HttpResponseMessage Get()
{
if (db.NOISE_SAMPLE == null || db.NOISE_SAMPLE.Count() == 0)
{
return(Request.CreateResponse(HttpStatusCode.OK, "[]"));
}
var keyValuePairs = Request.GetQueryNameValuePairs();
if (keyValuePairs.Count() < 4)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, "requst invalid"));
}
var options = RequestSamplesOptions.FromQuery(keyValuePairs);
var filteredSamples = SamplesAPI.getSamples(db, options);
if (filteredSamples == null)
{
Request.CreateResponse(HttpStatusCode.BadRequest, "requst invalid");
}
return(Request.CreateResponse(HttpStatusCode.OK, filteredSamples));
}
private async void Client_ApplicationMessageReceived(object sender, MqttApplicationMessageReceivedEventArgs e)
{
var topic = e.ApplicationMessage.Topic;
var payload = e.ApplicationMessage.Payload;
var result = System.Text.Encoding.UTF8.GetString(payload);
if (topic.Equals(NEW_MEASUREMENT_TOPIC_NAME))
{
var sample = JsonConvert.DeserializeObject <NOISE_SAMPLE>(result);
sample.userName = "******";
sample.Id = db.NOISE_SAMPLE.Count() == 0 ? 0 : (db.NOISE_SAMPLE.Max(x => x.Id) + 1);
db.NOISE_SAMPLE.Add(sample);
db.SaveChanges();
}
else if (topic.StartsWith("clients/", StringComparison.CurrentCulture) && topic.EndsWith("/request", StringComparison.CurrentCulture))
{
var requestOptions = JsonConvert.DeserializeObject <RequestSamplesOptions>(result);
var samples = SamplesAPI.getSamples(db, requestOptions);
var startOfTopic = topic.Substring(0, topic.Length - "/request".Length);
var jsonMsg = JsonConvert.SerializeObject(samples);
await client.PublishAsync(startOfTopic + "/response", jsonMsg);
}
}
public override IEnumerable <DocSample> CreateSamplesFromSourceFile(string filePath)
{
var result = new List <DocSample>();
var tree = CSharpSyntaxTree.ParseText(File.ReadAllText(filePath));
var treeRoot = tree.GetRoot() as CompilationUnitSyntax;
var csClasses = tree.GetRoot()
.DescendantNodes()
.OfType <ClassDeclarationSyntax>()
.ToList();
foreach (var csClass in csClasses)
{
var className = csClass.Identifier.ToString();
var classComment = string.Empty;
var trivia = csClass.GetLeadingTrivia();
if (trivia != null)
{
var commentXml = trivia.ToString();
try
{
classComment = XElement.Parse(trivia.ToString()
.Replace(@"///", string.Empty)
.Trim())
.FirstNode
.ToString()
.Trim()
.Replace(" ", "");
}
catch (Exception)
{
}
}
// methods
var csMethods = csClass
.DescendantNodes()
.OfType <MethodDeclarationSyntax>().ToList();
foreach (var csMethod in csMethods)
{
var namespaceName = ((csMethod.Parent as ClassDeclarationSyntax).Parent as NamespaceDeclarationSyntax).Name.ToString();
var methodName = csMethod.Identifier.Text;
var methodFullName = namespaceName + "." + className + "." + methodName;
// cleaning up attributes
var methodBodyWithFuntion = csMethod.ToString();
foreach (var methodAttr in csMethod.AttributeLists.ToList())
{
methodBodyWithFuntion = methodBodyWithFuntion.Replace(methodAttr.ToString(), string.Empty);
}
var sample = new DocSample();
// namespace
sample.Namespace = namespaceName;
sample.Language = "cs";
// class level
sample.ClassName = className;
sample.ClassFullName = namespaceName + "." + className;
sample.ClassComment = classComment;
// method
sample.MethodBodyWithFunction = methodBodyWithFuntion;
sample.MethodName = methodName;
sample.MethodFullName = methodFullName;
sample.MethodParametersCount = csMethod.ParameterList.ChildNodes().Count();
var hasOverload = csMethods.Count(m => m.Identifier.Text == methodName) > 1;
if (hasOverload)
{
sample.MethodName = methodName + "_" + sample.MethodParametersCount + "_Params";
}
sample.MethodBody = csMethod.Body
.ToString()
.TrimStart('{')
.TrimEnd('}');
sample.SourceFileName = Path.GetFileName(filePath);
sample.SourceFileNameWithoutExtension = Path.GetFileNameWithoutExtension(filePath);
sample.SourceFileFolder = Path.GetDirectoryName(filePath);
sample.SourceFilePath = filePath;
// TODO, metadata
sample.Title = string.Empty;
sample.Description = string.Empty;
// load from SampleMetadata attr
var instanceType = Type.GetType(sample.ClassFullName);
var method = instanceType.GetMethods().FirstOrDefault(m => m.Name == methodName);
if (method != null)
{
var methodMetadata = method.GetCustomAttributes(typeof(SampleMetadataAttribute), false)
.FirstOrDefault() as SampleMetadataAttribute;
if (methodMetadata != null)
{
sample.Title = methodMetadata.Title;
sample.Description = methodMetadata.Description;
}
else
{
// fallbak on the method name
sample.Title = method.Name;
}
// tags
var sampleTags = (method.GetCustomAttributes(typeof(SampleMetadataTagAttribute), false)
as SampleMetadataTagAttribute[]).ToList();
// addint top-class tags
sampleTags.AddRange(instanceType.GetCustomAttributes(typeof(SampleMetadataTagAttribute), false)
as SampleMetadataTagAttribute[]);
foreach (var tagNames in sampleTags.GroupBy(tag => tag.Name))
{
var newTag = new DocSampleTag
{
Name = tagNames.Key,
Values = tagNames.Select(t => t.Value).ToList()
};
sample.Tags.Add(newTag);
}
}
// use full body?
if (SamplesAPI.HasTag(sample, BuiltInTagNames.UseFullMethodBody))
{
sample.MethodBody = sample.MethodBodyWithFunction;
}
result.Add(sample);
}
}
return(result);
}
