private List <Feedbacks> FetchData(SqlCommand cmd)
{
SqlConnection con = cmd.Connection;
List <Feedbacks> feedbacks = null;
con.Open();
using (con)
{
SqlDataReader dr = cmd.ExecuteReader();
if (dr.HasRows)
{
feedbacks = new List <Feedbacks>();
while (dr.Read())
{
Feedbacks ufeedbacks = new Feedbacks();
ufeedbacks.FullName = Convert.ToString(dr["FullName"]);
ufeedbacks.EmailAddress = Convert.ToString(dr["EmailAddress"]);
ufeedbacks.ContactNumber = Convert.ToString(dr["ContactNumber"]);
ufeedbacks.FeedbackMsg = Convert.ToString(dr["FeedbackMsg"]);
ufeedbacks.MsgType = Convert.ToString(dr["MsgType"]);
feedbacks.Add(ufeedbacks);
}
feedbacks.TrimExcess();
}
}
return(feedbacks);
}
public ActionResult FeedbackE()
{
if (Request.HttpMethod == "POST")
{
String Nome = Request.Form["Nome"].ToString();
String Email = Request.Form["Email"].ToString();
String Mensagem = Request.Form["Mensagem"].ToString();
DateTime data = Convert.ToDateTime(Request.Form["Data"]);
Feedbacks f = new Feedbacks();
//ATRIBUILOS NA VARIAVEL
f.Nome = Nome;
f.Email = Email;
f.Mensagem = Mensagem;
f.Data = data;
if (f.Novo())
{
return(RedirectToAction("Feedback", "Home"));
}
else
{
ViewBag.MsgErro = "Não foi possivel fazer o Feedback, tente novamente!";
}
}
return(View());
}
public ActionResult FeedBack(FormCollection fc, Customers c, Feedbacks fd)
{
//while posting the dropdown instances from get method should be passed to post so that if they are empty
// we can suppress exceptions related to dropdown
//ViewBag.Chapterss = new SelectList(fb.Chapters, "Cid", "Cname");
//ViewBag.Productss = new SelectList(fb.Products, "Pid", "Pname");
Feedbacks feedback = new Feedbacks();
feedback.Custid = c.Custid;
feedback.Pid = Convert.ToInt32(fc[1]);
feedback.First = fd.First;
feedback.Second = fd.Second;
feedback.Third = fd.Third;
feedback.Fourth = fd.Fourth;
feedback.Fifth = fd.Fifth;
feedback.Sixth = fd.Sixth;
feedback.Seventh = fd.Seventh;
feedback.Addition = fc["Addition"];
feedback.Deletion = fc["Deletion"];
feedback.Comments = fc["Comments"];
feedback.Avg = (fd.First + fd.Second + fd.Third + fd.Fourth + fd.Fifth + fd.Sixth + fd.Seventh) / 7;
entities.Feedbacks.Add(feedback);
entities.SaveChanges();
return(RedirectToAction("SuccessPage", new RouteValueDictionary(c)));
}
public Rating AddRating(string userId, string itemId, float rating)
{
if (rating > _maxTarget)
{
_maxTarget = rating;
}
if (rating < _minTarget)
{
_minTarget = rating;
}
User u = AddUser(userId);
Item i = AddItem(itemId);
var r = new Rating(u, i, rating);
Feedbacks.Add(r);
u.Feedbacks.Add(r);
i.Feedbacks.Add(r);
FeedbacksDic.Add(userId, itemId, r);
return(r);
}
public async Task DeleteFeedback(Feedback feedback)
{
if (IsBusy)
{
return;
}
IsBusy = true;
var showAlert = false;
try {
await dataStore.RemoveFeedbackAsync(feedback);
Feedbacks.Remove(feedback);
Sort();
} catch (Exception ex) {
showAlert = true;
Xamarin.Insights.Report(ex);
}
finally {
IsBusy = false;
}
if (showAlert)
{
await page.DisplayAlert("Uh Oh :(", "Unable to delete feedback.", "OK");
}
}
public ActionResult Feedback()
{
if (Session["Paciente"] != null)
{
ViewBag.Logado = Session["Paciente"];
Paciente p = (Paciente)Session["Paciente"];
ViewBag.Nome = p.Nome;
ViewBag.Email = p.Email;
}
if (Session["Nutricionista"] != null)
{
ViewBag.LogadoN = Session["Nutricionista"];
Nutricionista n = (Nutricionista)Session["Adm"];
}
if (Session["Adm"] != null)
{
ViewBag.LogadoA = Session["Adm"];
Adm p = (Adm)Session["Adm"];
}
List <Feedbacks> f = Feedbacks.ListarF();
ViewBag.Feedback = f;
return(View());
}
public TesiraDspMeter(string key, TesiraMeterBlockConfig config, TesiraDsp parent)
: base(config.MeterInstanceTag, string.Empty, config.Index, 0, parent, string.Format(KeyFormatter, parent.Key, key), config.Label, config.BridgeIndex)
{
DeviceManager.AddDevice(this);
Label = config.Label;
Enabled = config.Enabled;
MeterFeedback = new IntFeedback(Key + "-MeterFeedback", () => _currentMeter);
SubscribedFeedback = new BoolFeedback(Key + "-SubscribedFeedback", () => IsSubscribed);
Feedbacks.Add(MeterFeedback);
Feedbacks.Add(SubscribedFeedback);
Feedbacks.Add(NameFeedback);
parent.Feedbacks.AddRange(Feedbacks);
if (config.MeterData != null)
{
var data = config.MeterData;
_meterMinimum = data.MeterMimimum;
_meterMaximum = data.MeterMaxiumum;
_defaultPollTime = data.DefaultPollTime;
}
else
{
_meterMinimum = MeterMinimumDefault;
_meterMaximum = MeterMaximumDefault;
_defaultPollTime = DefaultPollTimeDefault;
}
/*CrestronConsole.AddNewConsoleCommand(s => Subscribe(), "enablemeters", "", ConsoleAccessLevelEnum.AccessOperator);
* CrestronConsole.AddNewConsoleCommand(s => UnSubscribe(), "disablemeters", "", ConsoleAccessLevelEnum.AccessOperator);*/
}
public async Task <IActionResult> UpdateFeedback(FeedbackViewModel feedbackViewModel)
{
Feedbacks feedbacks = feedbackViewModel.feedbackDto;
int result = await _feedbackService.UpdateFeedback(feedbacks);
return(View("SuccessFeedbackClick", feedbackViewModel));
}
public Feedback AddFeedback(string userId, string itemId)
{
Feedback feedback;
if (!AllowDuplicates && FeedbacksDic.ContainsKey(userId, itemId))
{
feedback = FeedbacksDic[userId, itemId];
// promote a feedback to a higher level if it is already observed
// note that this assumes that the feedback are positive
//feedback.Level++;
return(feedback);
}
User u = AddUser(userId);
Item i = AddItem(itemId);
feedback = new Feedback(u, i);
Feedbacks.Add(feedback);
u.Feedbacks.Add(feedback);
i.Feedbacks.Add(feedback);
FeedbacksDic.Add(userId, itemId, feedback);
return(feedback);
}
public async Task <IActionResult> AddFeedback(int id, string textFeedback)
{
int idFb = 0;
var user = await _userManager.FindByNameAsync(User.Identity.Name);
using (GamesShopDB_Context db = new GamesShopDB_Context())
{
if (db.Feedback.Count() != 0)
{
idFb = db.Feedback.Max(p => p.IdFeedback + 1);
}
Feedbacks fb = new Feedbacks {
IdPokupatel = user.Id, IdGame = id, IdFeedback = idFb, TextOfFeedback = textFeedback, DateOfFeedback = DateTime.Now
};
// Добавление
db.Feedback.Add(fb);
db.SaveChanges();
}
return(RedirectToAction("ListGames"));
}
public async Task <IActionResult> PutFeedbacks([FromRoute] int id, [FromBody] Feedbacks feedbacks)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != feedbacks.Id)
{
return(BadRequest());
}
_context.Feedback.Update(feedbacks);
try
{
await _context.Save();
}
catch (DbUpdateConcurrencyException)
{
if (!FeedbacksExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <Feedbacks> GetNamesForFeedback(string id)
{
var repo = new TableStorageRepository();
var feedback = await repo.GetFeedByFeedId(id);
var users = await repo.GetUsersWithoutParams();
var names = new Feedbacks {
};
foreach (var user in users)
{
if (user.Id == feedback.ID)
{
feedback.ID = user.Name;
}
if (user.Id == feedback.ID_receiver)
{
feedback.ID_receiver = user.Name;
}
if (user.Id == feedback.ID_manager)
{
feedback.ID_manager = user.Name;
}
}
return(feedback);
}
public ActionResult Feedback(Feedbacks fed)
{
_context.Feedbacks.Add(fed);
_context.SaveChanges();
return(RedirectToAction("Index", "Home"));
}
public void SaveAsRating(string path)
{
var header = new string[] { "UserId,ItemId,Rating" };
var output = Feedbacks.Select(f => string.Format("{0},{1},{2:0.00000}", f.User.Id, f.Item.Id, ((Rating)f).Value));
File.WriteAllLines(path, header.Concat(output));
}
public ActionResult Details(int id)
{
Feedbacks fb = entities.Feedbacks.FirstOrDefault(x => x.Fid == id);
Chapters temp = entities.Chapters.FirstOrDefault(x => x.Cid == fb.Products.Cid);
return(View(fb));
}
public async Task ExecuteGetFeedbackCommand()
{
if (IsBusy)
{
return;
}
IsBusy = true;
try{
Feedbacks.Clear();
var feedbacks = await dataStore.GetFeedbackAsync();
foreach (var feedback in feedbacks)
{
Feedbacks.Add(feedback);
}
Sort();
}catch (Exception ex) {
Xamarin.Insights.Report(ex);
page.DisplayAlert("Uh oh :(", "Unable to get feedback, pull to refresh when online", "OK");
}
finally {
IsBusy = false;
}
}
public ActionResult DeleteConfirmed(int id)
{
Feedbacks feedbacks = db.Feedbacks.Find(id);
db.Feedbacks.Remove(feedbacks);
db.SaveChanges();
return(RedirectToAction("Index"));
}
/// <inheritdoc />
public virtual IFeedbackDto?GetFeedback(string objectId)
{
var id = objectId.FromServiceString <Guid>();
return(Feedbacks
.AsNoTracking()
.FirstOrDefault(f => f.Id == id));
}
public IActionResult Feedback()
{
Feedbacks cus1 = SessionHelper.GetObjectFromJson <Feedbacks>(HttpContext.Session, "cust");
Customers c = SessionHelper.GetObjectFromJson <Customers>(HttpContext.Session, "cust");
ViewBag.cusname = c.UserName;
return(View(cus1));
}
public async Task <IActionResult> EditFeedback(Feedbacks fb)
{
Console.WriteLine("Feedback id:" + fb.TextOfFeedback);
db.Attach(fb).State = EntityState.Modified;
await db.SaveChangesAsync();
ViewData["MessageEdit"] = "Отзыв был успешно отредактирован!";
return(View());
}
public async Task <int> CreateFeedback(Feedbacks feedbacks)
{
_context.Feedback.Add(feedbacks);
var result = await _context.SaveChangesAsync();
var createdFeedback = (await _context.Feedback.FirstAsync(s => s.PromotionId == feedbacks.PromotionId)).PromotionId;
return(createdFeedback);
}
/// <summary>
/// Gets the reputation.
/// </summary>
/// <returns>A floating point value representing the reputation.</returns>
public virtual float GetReputation() // 'virtual' to be easily stubbed.
{
if (Feedbacks == null || Feedbacks.Count == 0)
{
return(0);
}
return((float)Feedbacks.Average(f => f.Score));
}
/// <summary>
/// Initializes this attribute based on config values and generates subscriptions commands and adds commands to the parent's queue.
/// </summary>
/// <param name="config">Configuration Object</param>
private void Initialize(TesiraRoomCombinerBlockConfig config)
{
if (config.Enabled)
{
DeviceManager.AddDevice(this);
}
Debug.Console(2, this, "Adding RoomCombiner '{0}'", Key);
IsSubscribed = false;
HasMute = config.HasMute;
HasLevel = config.HasLevel;
UseAbsoluteValue = config.UseAbsoluteValue;
Enabled = config.Enabled;
Permissions = config.Permissions;
IncrementAmount = config.IncrementAmount;
AutomaticUnmuteOnVolumeUp = config.UnmuteOnVolChange;
_volumeUpRepeatTimer = new CTimer((o) => VolumeUpRepeat(), Timeout.Infinite);
_volumeDownRepeatTimer = new CTimer((o) => VolumeDownRepeat(), Timeout.Infinite);
_volumeUpRepeatDelayTimer = new CTimer((o) => VolumeUpRepeatDelay(), Timeout.Infinite);
_volumeDownRepeatDelayTimer = new CTimer((o) => VolumeDownRepeatDelay(), Timeout.Infinite);
_pollTimer = new CTimer((o) => DoPoll(), Timeout.Infinite);
if (HasMute && HasLevel)
{
ControlType = 0;
}
else if (!HasMute && HasLevel)
{
ControlType = 1;
}
else if (HasMute && !HasLevel)
{
ControlType = 2;
}
MuteFeedback = new BoolFeedback(Key + "-MuteFeedback", () => OutIsMuted);
VisibleFeedback = new BoolFeedback(Key + "-VisibleFeedback", () => Enabled);
RoomGroupFeedback = new IntFeedback(Key + "-RoomGroupFeedback", () => RoomGroup);
VolumeLevelFeedback = new IntFeedback(Key + "-LevelFeedback", () => OutVolumeLevel);
ControlTypeFeedback = new IntFeedback(Key + "-ControlTypeFeedback", () => ControlType);
PermissionsFeedback = new IntFeedback(Key + "-PermissionsFeedback", () => Permissions);
Feedbacks.Add(MuteFeedback);
Feedbacks.Add(VolumeLevelFeedback);
Feedbacks.Add(NameFeedback);
Feedbacks.Add(VisibleFeedback);
Feedbacks.Add(ControlTypeFeedback);
Feedbacks.Add(PermissionsFeedback);
Parent.Feedbacks.AddRange(Feedbacks);
}
public IActionResult Feedback(Feedbacks fed)
{
Customers c = SessionHelper.GetObjectFromJson <Customers>(HttpContext.Session, "cust");
fed.CustomerId = c.CustomerId;
_context.Feedbacks.Add(fed);
_context.SaveChanges();
return(RedirectToAction("Index", "Home"));
}
public async Task <int> UpdateFeedback(Feedbacks feedbacks)
{
_context.Feedback.Update(feedbacks);
var result = await _context.SaveChangesAsync();
var updatedFeedbackData = feedbacks.PromotionId;
return(updatedFeedbackData);
}
public async Task <IActionResult> Like(Feedbacks feedback, int likecount)
{
string currentuser = "";
var userAuth = await _userManager.FindByEmailAsync(HttpContext.User.Identity.Name);
currentuser = userAuth.Id;
bool isliked = (from feed in _context.Feedbacks
where feed.UserId == currentuser
select feed.Like).FirstOrDefault();
var user = (from feed in _context.Feedbacks
where feed.UserId == currentuser
select feed).FirstOrDefault();
if (user == null)
{
Feedbacks feed = new Feedbacks();
feed.UserId = currentuser;
feed.Like = true;
feed.DisLike = false;
feed.LikeCount += 1;
if (_context.Feedbacks.ToList().Count() == 0)
{
likecount += 1;
}
else
{
likecount = _context.Feedbacks.Select(x => x.LikeCount).Sum() + 1;
}
_context.Feedbacks.Add(feed);
await _context.SaveChangesAsync();
}
else
{
feedback.UserId = currentuser;
if (User.Identity.IsAuthenticated && isliked)
{
user.Like = false;
user.DisLike = false;
user.LikeCount -= 1;
likecount = _context.Feedbacks.Select(x => x.LikeCount).Sum() - 1;
}
else
{
user.Like = true;
user.DisLike = false;
user.LikeCount += 1;
likecount = _context.Feedbacks.Select(x => x.LikeCount).Sum() + 1;
}
_context.Update(user);
await _context.SaveChangesAsync();
}
return(Json(new { status = "200", likecount, isliked }));
}
/// <inheritdoc />
public IFeedbackDto AddFeedback(FeedbackDto entity)
{
if (entity.Id == Guid.Empty)
{
entity.Id = CreateSequentialGuid();
}
Feedbacks.Add(entity);
return(entity);
}
public IActionResult NewFeedback([Bind("Id,Comments")] Feedbacks feedbacks)
{
if (ModelState.IsValid)
{
_context.Add(feedbacks);
_context.SaveChanges();
return(RedirectToAction(nameof(Feedbacks)));
}
return(View(feedbacks));
}
public TwoWayDisplayBase(string key, string name)
: base(key, name)
{
CurrentInputFeedback = new StringFeedback(CurrentInputFeedbackFunc);
WarmupTime = 7000;
CooldownTime = 15000;
Feedbacks.Add(CurrentInputFeedback);
}
public async Task <Feedbacks> GiveFeedback(Feedbacks feedback)
{
feedback.RowKey = Guid.NewGuid().ToString();
await feedbacksTable.CreateIfNotExistsAsync();
TableOperation insertOperation = TableOperation.InsertOrReplace(feedback);
var result = await feedbacksTable.ExecuteAsync(insertOperation);
return(feedback);
}
public void EditFeedback(Feedbacks updatedFeedback)
{
updatedFeedback.DateTime = DateTime.Today.ToShortDateString() + " в " + DateTime.Now.ToLongTimeString();
db = new MyBlogEntities();// without this updating dosen't work
db.Entry(updatedFeedback).State = EntityState.Modified;
db.SaveChanges();
}
public void AddFeedback(Feedbacks feedback)
{
feedback.DateTime = DateTime.Today.ToShortDateString() + " в " + DateTime.Now.ToLongTimeString();
int id = db.Users.Where(item => item.Nick == feedback.Users.Nick).Select(item=>item.Id).FirstOrDefault();
if (id != 0)
{
feedback.Users = null;
feedback.UserId = id;
}
db.Feedbacks.Add(feedback);
db.SaveChanges();
}
