private async void _OpcProcessor_TagValidated(Models.Tag tag)
{
if (tag != null)
{
var pos = MainLineCollection.FirstOrDefault(x => x.X == tag.Handle);
var errp = MainLineCollection.Count(x => x.Y > LimSup || x.Y < LimInf);
if (pos != null)
{
await Task.Delay(_Delay).ContinueWith(async(h) =>
{
pos.Y = _gaugeXlValue;
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal,
() =>
{
MainLineSeries.Refresh();
labelActual.Text = _gaugeXlValue.ToString("00.00");
bool error = errp > LimErr / 100 * MainLineCollection.Count;
WarningBanner.Background = error ? new SolidColorBrush(Windows.UI.Color.FromArgb(255, 255, 0, 0)) : new SolidColorBrush(Windows.UI.Color.FromArgb(255, 255, 255, 255));
var avg = MainLineCollection.Average(x => x.Y);
labelPromedio.Text = avg.ToString("00.00");
labelPaso.Text = "Pos. " + (MainLineCollection.IndexOf(pos) + 1);
});
});
}
}
}
public async Task <ActionResult <Models.Tag> > PostTag(Models.Tag tag)
{
_context.Tags.Add(tag);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetTag", new { id = tag.Id }, tag));
}
public async Task <IActionResult> AddTagToEntry(int id, [FromBody] Models.Tag tag, [FromServices] ApplicationDbContext db)
{
var entry = await db.Entries.SingleOrDefaultAsync(i => i.Id == id);
if (entry == null)
{
return(NotFound("Entry not found"));
}
var dbTag = await db.Tags.SingleOrDefaultAsync(i => i.Name.Equals(tag.Name, StringComparison.InvariantCultureIgnoreCase));
if (dbTag == null)
{
dbTag = new Data.Tag()
{
Name = tag.Name
};
db.Tags.Add(dbTag);
}
var ec = await db.EntryTags.SingleOrDefaultAsync(e => e.TagId == dbTag.Id && e.EntryId == entry.Id);
if (ec == null)
{
ec = new EntryTag()
{
Tag = dbTag, Entry = entry
};
db.EntryTags.AddRange(ec);
await db.SaveChangesAsync();
}
return(Created("", dbTag));
}
private Models.Tag MapItemToTag(Dictionary <string, AttributeValue> item)
{
try
{
var tag = new Models.Tag();
if (item.ContainsKey(TableContent.Title.ToString()))
{
tag.title = item[TableContent.Title.ToString()].S;
}
if (item.ContainsKey(TableContent.Name.ToString()))
{
tag.uniqueName = item[TableContent.Name.ToString()].S;
}
if (item.ContainsKey(TableContent.CreatedOn.ToString()))
{
var success = int.TryParse(item[TableContent.CreatedOn.ToString()].N, out int date);
if (success)
{
tag.createdOn = date;
}
}
return(tag);
}
catch (Exception ex)
{
Console.WriteLine($"ERROR: MapItemToTag problem. Error: {ex.Message}. {ex.StackTrace}.");
return(null);
}
}
public IEnumerable <Models.Tag> LoadTags()
{
foreach (var line in ReadLines("tags.csv"))
{
var fields = Data.CsvParser.Instance.ParseLine(line);
if (fields.Count < 4)
{
continue;
}
int num;
if (!int.TryParse(fields[0], out num))
{
continue;
}
var item = new Models.Tag();
item.UserId = num;
if (!int.TryParse(fields[1], out num))
{
continue;
}
item.MovieId = num;
item.Value = fields[2];
item.Created = Data.DateTimeUtils.ParseFromJava(fields[3], 1000);
yield return(item);
}
}
/// <summary>
/// adds story in given tag
/// </summary>
/// <param name="userName">story's author</param>
/// <param name="story">story's title</param>
/// <param name="tag">tag to add</param>
/// <returns>if the story was added</returns>
public async Task <bool> AddStoryInTagAsync(string userName, string story, string tag)
{
try
{
var tagFromDB = await GetTagAsync(tag);
if (tagFromDB == null)
{
var tagToAdd = new Models.Tag(tag);
tagToAdd.Stories.Add(new Tuple <string, string>(userName, story));
await _context.Tags.InsertOneAsync(tagToAdd);
return(true);
}
tagFromDB.Stories.Add(new Tuple <string, string>(userName, story));
var result = await _context.Tags.ReplaceOneAsync(t => t.Context.Equals(tag), tagFromDB);
if (result.ModifiedCount > 0)
{
return(true);
}
}
catch (Exception e)
{
_logger.LogError($"Error while adding story in tag\n {e.Message}");
}
return(false);
}
public async Task <IActionResult> PutTag(int id, Models.Tag tag)
{
if (id != tag.Id)
{
return(BadRequest());
}
_context.Entry(tag).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TagExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async void TestUpdateWithTeam()
{
String accessToken = this.RandomString();
String teamId = this.RandomString();
Models.Tag tag = new Models.Tag();
tag.TagId = this.RandomString();
tag.TagData = new Models.TagData();
tag.TagData.Name = this.RandomString();
UpdateTagRequest req = new UpdateTagRequest();
req.Tag = tag;
req.TeamId = teamId;
MockAPI <Tags> mock = this.MockFor <Tags>(
HttpMethod.Post,
"/api/v1/tags.update",
m => m.WithContent(req.ToString())
.Respond("application/json", req.ToString())
);
APIResponse <TagResponseBody> res = await mock.Instance.Update(accessToken, tag, teamId);
mock.Handler.VerifyNoOutstandingExpectation();
Assert.Equal(tag.TagId, res.Body.Tag.TagId);
}
public IActionResult OnGet(string tagStr)
{
if (!HttpContext.Session.Keys.Contains("auid"))
{
return(RedirectToPage("/Auth/Login"));
}
if (tagStr != null)
{
var sqlCmd = $"select id,latin_name, russian_name from tags where " +
$"((lower(latin_name) like '%{tagStr.ToLower()}%' " +
$"or lower(russian_name) like '%{tagStr.ToLower()}%')" +
$"and EXISTS(select id from tags_tax_nodes where tag_id = tags.id))";
var cmd = new NpgsqlCommand(sqlCmd, DBConnect.Connection);
var reader = cmd.ExecuteReader();
List <Models.Tag> taglist = new List <Models.Tag>();
while (reader.Read())
{
var tag = new Models.Tag();
tag.Id = reader.GetInt32(0);
tag.LatinName = reader.GetString(1);
tag.RussianName = reader.GetString(2);
taglist.Add(tag);
}
reader.Close();
cmd.Dispose();
return(new JsonResult(taglist));
}
return(Page());
}
public IActionResult OnPost(int?id, string latinNameInput, string russianNameInput)
{
if (!HttpContext.Session.Keys.Contains("auid"))
{
return(RedirectToPage("/Auth/Login"));
}
if (id.HasValue && latinNameInput != null && russianNameInput != null)
{
var tag = new Models.Tag {
Id = id.Value, LatinName = latinNameInput, RussianName = russianNameInput
};
try
{
tag.Update();
}
catch (InfoException e)
{
WarningInfo = e.Message;
}
if (WarningInfo == "")
{
SuccesInfo = StringResources.StringResources.Instance.SuccesCreated;
}
}
return(RedirectToPage("./Index"));
}
private void AddToTags_Click(object sender, RoutedEventArgs e)
{
List <string> tags = new List <string>();
if (App.Settings.current_tag_code != null)
{
tags = App.Settings.current_tag_code.Split(new char[] { '+' }).ToList();
}
System.Diagnostics.Debug.WriteLine("App.Settings.current_tag_code:" + App.Settings.current_tag_code);
tags.Add(menuTag.Code);
System.Diagnostics.Debug.WriteLine("menuTag.Code:" + menuTag.Code);
string newTagCode = String.Join("+", tags.OrderBy(x => x).Distinct().ToArray());
System.Diagnostics.Debug.WriteLine("newTagCode:" + newTagCode);
menuTag = new Models.Tag()
{
Name = newTagCode,
Code = newTagCode,
SiteUrl = App.Settings.current_site
};
OpenTag_Click(sender, e);
}
public ActionResult <IEnumerable <Post> > Get(string?tag)
{
if (tag != null)
{
Models.Tag tagEntity = _context.Tags.Where(w => w.title == tag).FirstOrDefault();
if (tagEntity != null)
{
List <Models.Post> postsTemp = _context.PostsTags.Include(i => i.Post).
Where(w => w.TagID == tagEntity.TagID).
Select(s => s.Post).
OrderByDescending(o => o.createdAt).
ToList();
List <Models.Post> postsTemp1 = new List <Models.Post>();
foreach (Models.Post p in postsTemp)
{
postsTemp1.Add(_context.Posts.Include("tagList.Tag").Where(w => w.PostID == p.PostID).FirstOrDefault());
}
return(_mapper.Map <List <Post> >(postsTemp1));
}
else
{
return(NotFound());
}
}
List <Models.Post> posts = _context.Posts.Include("tagList.Tag").
OrderByDescending(o => o.createdAt).
ToList();
return(_mapper.Map <List <Post> >(posts));
}
public ActionResult Save(string sourceType, string moduleKey, EditTagViewModel editTag)
{
var result = new DataJsonResult();
if (editTag.Id == Guid.Empty)
{
var tag = new Models.Tag
{
Id = KeyGenerator.GetGuidKey(),
ModuleKey = moduleKey,
SourceType = sourceType,
Content = editTag.Content,
CreateTime = DateTime.Now,
Sort = editTag.Sort
};
_currencyService.Create(tag);
}
else
{
var tag = _currencyService.GetSingleById <Models.Tag>(editTag.Id);
tag.Content = editTag.Content;
tag.Sort = editTag.Sort;
_currencyService.Update(tag);
}
return(Json(result));
}
public async Task <bool> PostTagAsync(Models.Tag tag)
{
string uri = AppSettings.TagsEndpoint;
var token = await _loginService.GetOAuthToken();
return(await _requestService.PostAsync <Models.Tag, bool>(uri, tag, token));
}
public void Create(Models.Tag tag)
{
using (var context = new ArticlesContext())
{
context.Tags.Add(tag);
context.SaveChanges();
}
}
public static Tag Convert(Models.Tag user)
{
return(new Tag
{
TagId = user.TagId,
Name = user.Name
});
}
public void Add()
{
var tag = new Models.Tag
{
Name = ".Net",
};
Console.WriteLine(EventsXdService.Tags.Add(5577, tag));
}
public Data.Tag ReverseConvert(Models.Tag value)
{
return(new Data.Tag
{
ID = value.ID,
Name = value.Name,
Description = value.Description
});
}
public void Update()
{
var tag = new Models.Tag
{
Name = "C#",
Id = "19869"
};
Console.WriteLine(EventsXdService.Tags.Update(5577, tag));
}
public void Update(Models.Tag tag)
{
var existing = db.Tags.SingleOrDefault(x => x.Id == tag.Id);
if (existing != null)
{
existing.Name = tag.Name;
db.SaveChanges();
}
}
public async Task <Models.Tag[]> HandleTags(int userId, string[][] megaTags)
{
List <Models.Tag> applyTags = new List <Models.Tag>();
Models.Tag newTag = new Models.Tag();
//TODO: Figure out how to derive the current user of app and pass their user id instead
foreach (string curPeople in megaTags.ElementAt(0))
{
newTag = new Models.Tag {
Name = curPeople, TagType = "People", Updated = DateTime.Now, Created = DateTime.Now
};
int newTagId = await this.AddTagAsync(newTag).ConfigureAwait(false);
applyTags.Add(await FindTagAsync(newTagId).ConfigureAwait(false));
}
foreach (string curPlaces in megaTags.ElementAt(1))
{
newTag = new Models.Tag {
Name = curPlaces, TagType = "Places", Updated = DateTime.Now, Created = DateTime.Now
};
int newTagId = await this.AddTagAsync(newTag).ConfigureAwait(false);
applyTags.Add(await FindTagAsync(newTagId).ConfigureAwait(false));
}
foreach (string curEvents in megaTags.ElementAt(2))
{
newTag = new Models.Tag {
Name = curEvents, TagType = "Events", Updated = DateTime.Now, Created = DateTime.Now
};
int newTagId = await this.AddTagAsync(newTag).ConfigureAwait(false);
applyTags.Add(await FindTagAsync(newTagId).ConfigureAwait(false));
}
foreach (string curCustom in megaTags.ElementAt(3))
{
newTag = new Models.Tag {
Name = curCustom, TagType = "Custom", Updated = DateTime.Now, Created = DateTime.Now
};
int newTagId = await this.AddTagAsync(newTag).ConfigureAwait(false);
applyTags.Add(await FindTagAsync(newTagId).ConfigureAwait(false));
}
foreach (string curRelationship in megaTags.ElementAt(4))
{
newTag = new Models.Tag {
Name = curRelationship, TagType = "Relationship", Updated = DateTime.Now, Created = DateTime.Now
};
int newTagId = await this.AddTagAsync(newTag).ConfigureAwait(false);
applyTags.Add(await FindTagAsync(newTagId).ConfigureAwait(false));
}
return(applyTags.ToArray());
}
public int Insert(Models.Tag tag)
{
tblTag newTag = new tblTag {
Name = tag.Name
};
db.Tags.Add(newTag);
db.SaveChanges();
return(newTag.Id);
}
public async Task <IActionResult> Update([FromBody] Models.Tag tagToAdd)
{
using (var context = new Models.EventuallyContext()) {
context.Tags.Update(tagToAdd);
context.SaveChanges();
}
var tagId = new { TagId = tagToAdd.Id };
return(Ok(tagId));
}
private void SearchInputOpenTag(object sender, RoutedEventArgs e)
{
menuTag = new Models.Tag()
{
Name = SearchInput.Text,
Code = SearchInput.Text.ToLower(),
SiteUrl = App.Settings.current_site
};
SearchInput.Text = "";
OpenTag_Click(sender, e);
}
private void OpenTagOnThisSIte_Click(object sender, RoutedEventArgs e)
{
menuTag = new Models.Tag()
{
Name = menuTag.Name,
Code = menuTag.Code,
SiteUrl = App.Settings.current_site
};
OpenTag_Click(sender, e);
}
public async Task TagRepository() {
var id = Guid.Empty;
// Insert tag
using (var api = new Api()) {
var tag = new Models.Tag() {
Name = "My tag",
};
api.Tags.Add(tag);
Assert.AreEqual(tag.Id.HasValue, true);
Assert.IsTrue(api.SaveChanges() > 0);
id = tag.Id.Value;
}
// Get by slug
using (var api = new Api()) {
var tag = await api.Tags.GetBySlugAsync("my-tag");
Assert.IsNotNull(tag);
Assert.AreEqual(tag.Name, "My tag");
}
// Update tag
using (var api = new Api()) {
var tag = await api.Tags.GetBySlugAsync("my-tag");
Assert.IsNotNull(tag);
tag.Name = "My updated tag";
api.Tags.Add(tag);
Assert.IsTrue(api.SaveChanges() > 0);
}
// Get by id
using (var api = new Api()) {
var tag = await api.Tags.GetByIdAsync(id);
Assert.IsNotNull(tag);
Assert.AreEqual(tag.Name, "My updated tag");
}
// Remove tag
using (var api = new Api()) {
var tag = await api.Tags.GetBySlugAsync("my-tag");
api.Tags.Remove(tag);
Assert.IsTrue(api.SaveChanges() > 0);
}
}
public IActionResult OnGet(int id)
{
if (!HttpContext.Session.Keys.Contains("auid"))
{
return(RedirectToPage("/Auth/Login"));
}
Tag = Models.Tag.GetById(id);
if (Tag == null)
{
return(RedirectToPage("/Auth/Login"));
}
return(Page());
}
public void DeleteTest()
{
Tag tag = new Tag();
List <Models.Tag> tags = new List <Models.Tag>();
tags = tag.Load();
Models.Tag row = tags.Where(x => x.Id == 2).FirstOrDefault();
if (row != null)
{
bool actual = tag.Delete(row.Id);
Assert.IsTrue(actual == true);
}
}
public ActionResult Update(string id)
{
Areas.Models.Tag tag = new Models.Tag();
if (Session["login"] == null)
{
return(RedirectToAction("Index", "Login"));
}
else
{
tag = DAL.Tag.getTag(id);
return(View(tag));
}
}
private void Button_RightTapped(object sender, RightTappedRoutedEventArgs e)
{
if (tagMenuIsOpen)
{
return;
}
Button button = sender as Button;
menuTag = button.DataContext as Models.Tag;
InitMenu();
TagMenu.ShowAt(button, e.GetPosition(button));
}
public ActionResult Edit(string id)
{
blog_tb_tag model = new blog_tb_tag {
ADD_DATE = DateTime.Now, UPDATE_DATE = DateTime.Now
};
if ((!String.IsNullOrEmpty(id)) && id.ToString() != "0")
{
model = Utility.TagBll.GetEntity(id);
model.UPDATE_DATE = DateTime.Now;
}
Models.Tag tag = ObjectHelper.CloneProperties <Models.Tag>(model);
return(View("~/Views/" + Utility.Version + "/Tag/Edit.cshtml", tag));
}
public static bool ImportedData(Stream stream, BlogPostDb db)
{
var deserialiser = new XmlSerializer(typeof(BlogPost[]));
try
{
BlogPost[] posts;
using (var streamReader = new StreamReader(stream))
{
using (var xmlReader = XmlReader.Create(streamReader))
{
posts = (BlogPost[])deserialiser.Deserialize(xmlReader);
}
}
var newTags = new Dictionary<string, Models.Tag>();
foreach (var post in posts)
{
var dbPost = new CjbHome.Models.BlogPost
{
LinkText = post.LinkText,
Title = post.Title,
PostDate = post.PostDate,
PostTime = post.PostTime,
Content = post.Content,
HeaderImageUrl = post.HeaderImageUrl,
Tags = new List<CjbHome.Models.Tag>()
};
foreach (var tagString in post.Tags)
{
var blogTag = db.Tags.FirstOrDefault(t => t.Title == tagString);
if (blogTag == null)
{
if (!newTags.TryGetValue(tagString, out blogTag))
{
blogTag = new Models.Tag { Title = tagString };
db.Tags.Add(blogTag);
newTags.Add(tagString, blogTag);
}
}
dbPost.Tags.Add(blogTag);
}
var existingPost = db.BlogPosts.FirstOrDefault(p => p.LinkText == dbPost.LinkText);
if (existingPost != null)
{
db.BlogPosts.Remove(existingPost);
}
db.BlogPosts.Add(dbPost);
}
db.SaveChanges();
return true;
}
catch (Exception ex)
{
return false;
}
}
/// <summary>
/// Create a user to tag association by appending a new tag to the user's list of tags
/// </summary>
/// <param name="pin"></param>
/// <param name="label"></param>
/// <returns></returns>
public async Task<JsonResult> RegisterTag (string pin, string label, string UID)
{
if (pin == null || label == null || UID == null)
{
return Json(new
{
success = false,
message = "missing one or more parameters"
}, JsonRequestBehavior.AllowGet);
}
var success = false;
var message = "";
var ObjectId = new ObjectId(UID);
//make sure the user exists
var user = await ZDB.Users.Find(x => x.Id == UID).FirstOrDefaultAsync();
if(user!= null)
{
success = true;
IdentitySample.Models.Tag currentTag = new Models.Tag { label = label, pin = pin };
var result = await ZDB.Users.UpdateOneAsync(x => x.Id == UID, Builders<ApplicationUser>.Update.Push(x => x.Tags, currentTag));
}
else
{
message = "no such user found";
}
return Json(new
{
success = success
}, JsonRequestBehavior.AllowGet);
}
/// <summary>
/// Adds the tags to the given post.
/// </summary>
/// <param name="api">The current api</param>
/// <param name="post">The post</param>
/// <param name="tags">The tags</param>
private static void AddTags(IApi api, Models.Post post, string[] tags) {
post.Tags.Clear();
foreach (var tag in tags) {
var t = api.Tags.GetBySlug(Utils.GenerateSlug(tag));
if (t == null)
t = new Models.Tag() {
Name = tag
};
post.Tags.Add(t);
}
}
