public IActionResult ObterPregoes()
{
var ret = _financeService.GetFinances().ToList();
List <GuideModel> lst = new List <GuideModel>();
foreach (var o in ret)
{
var guide = new GuideModel()
{
ChartPreviousClose = o.ChartPreviousClose
, Currency = o.Currency
, DataGranularity = o.DataGranularity
, ExchangeName = o.ExchangeName
, ExchangeTimezoneName = o.ExchangeTimezoneName
, FirstTradeDate = o.FirstTradeDate
, Gmtoffset = o.Gmtoffset
, InstrumentType = o.InstrumentType
, Id = o.Id
, PreviousClose = o.PreviousClose
, PriceHint = o.PriceHint
, Range = o.Range
, RegularMarketPrice = o.RegularMarketPrice
, RegularMarketTime = o.RegularMarketTime
, Scale = o.Scale
, Symbol = o.Symbol
, Timezone = o.Timezone
};
lst.Add(guide);
}
return(Ok(lst));
}
public List <GuideModel> Get()
{
var guides = unitOfWork.GuideRepository.GetAll().ToList();
var guideModelList = new List <GuideModel>();
foreach (var g in guides)
{
var guideModel = new GuideModel {
GuideId = g.GuideId,
IdentityId = g.IdentityId,
FirstName = g.FirstName,
LastName = g.LastName,
Address = g.Address,
City = g.City,
Phone = g.Phone,
Email = g.Email,
Notes = g.Notes,
IsAdmin = g.IsAdmin,
IsMember = g.IsMember,
Dogs = g.Dogs.Select(d => new IdNameModel {
Id = d.DogId, Name = d.Name
}).ToList(),
EventIds = g.GuideEvents?.Select(e => e.EventId).ToList()
};
guideModelList.Add(guideModel);
}
return(guideModelList);
}
public void RefreshEpg(GuideModel model)
{
_model = model;
_epgChannelsControl.RefreshEpg(model);
_epgProgramsControl.RefreshEpg(model);
SetTimeIndicator();
}
public async void ShouldNotUpdateGuideIfGameNotFound()
{
var id = 1;
var guideModel = new GuideModel();
var repo = new Mock <IRepository <Guide> >();
var gameRepo = new Mock <IRepository <Game> >();
var userRepo = new Mock <IRepository <User> >();
var reviewRepo = new Mock <IRepository <GuideReview> >();
var guide = new Guide();
repo.Setup(x => x.GetSingleEntity(It.IsAny <Expression <Func <Guide, bool> > >())).Returns(Task.FromResult(guide));
userRepo.Setup(x => x.Exists(It.IsAny <Expression <Func <User, bool> > >())).Returns(Task.FromResult(true));
gameRepo.Setup(x => x.Exists(It.IsAny <Expression <Func <Game, bool> > >())).Returns(Task.FromResult(false));
var guideService = new GuideService(repo.Object, gameRepo.Object, userRepo.Object, reviewRepo.Object);
var guideController = new GuideController(guideService);
var result = await guideController.UpdateGuide(id, guideModel);
var badRequest = Assert.IsType <BadRequestObjectResult>(result);
var errorResult = Assert.IsAssignableFrom <ResultDto <BaseDto> >(badRequest.Value);
string error = "Podana gra nie została znaleziona";
Assert.Contains(error, errorResult.Error);
}
public GuideModel Get(int id)
{
//return unitOfWork.GuideRepository.GetById(id);
var g = unitOfWork.GuideRepository.GetById(id);
var guideModel = new GuideModel()
{
GuideId = g.GuideId,
IdentityId = g.IdentityId,
FirstName = g.FirstName,
LastName = g.LastName,
Address = g.Address,
City = g.City,
Phone = g.Phone,
Email = g.Email,
Notes = g.Notes,
IsAdmin = g.IsAdmin,
IsMember = g.IsMember,
Dogs = g.Dogs.Select(d => new IdNameModel {
Id = d.DogId, Name = d.Name
}).ToList(),
EventIds = g.GuideEvents?.Select(e => e.EventId).ToList()
};
return(guideModel);
}
public IActionResult Put(int id, [FromBody] GuideModel obj)
{
if (!IsCurrentUserAdmin() && id != GetCurrentUserId())
{
return(Forbid());
}
var guide = unitOfWork.GuideRepository.GetById(id);
var guideModel = obj;
guide.Address = guideModel.Address;
guide.City = guideModel.City;
guide.Email = guideModel.Email;
guide.FirstName = guideModel.FirstName;
guide.LastName = guideModel.LastName;
guide.Notes = guideModel.Notes;
guide.Phone = guideModel.Phone;
guide.IsAdmin = guideModel.IsAdmin;
guide.IsMember = guideModel.IsMember;
//var allDogs = unitOfWork.DogRepository.GetAll();
//var dogIds = guideModel.Dogs.Select(x => x.Id).ToList();
//var dogs = allDogs.Where(d => dogIds.Contains(d.DogID)).ToList();
//guide.Dogs = dogs;
unitOfWork.Commit();
return(new ObjectResult(guide.GuideId));
}
//metoda dodania poradnika
public async Task <ResultDto <BaseDto> > AddGuide(GuideModel guideModel)
{
var result = new ResultDto <BaseDto>()
{
Error = null
};
//sprawdzam czy użytkownik istnieje
bool userExists = await _userRepo.Exists(x => x.Id == guideModel.Author);
if (!userExists)
{
result.Error = "Autor poradnika nie został odnaleziony";
return(result);
}
//sprawdzam czy gra istnieje
bool gameExists = await _gameRepo.Exists(x => x.Id == guideModel.Game);
if (!gameExists)
{
result.Error = "Podana gra nie została znaleziona";
return(result);
}
//sprawdzam czy istnieje poradnik o podanej nazwie
bool guideExists = await _guideRepo.Exists(x => x.Name == guideModel.Name);
if (guideExists)
{
result.Error = "Podana nazwa jest już w użyciu";
return(result);
}
//tworze nowy poradnik
var guide = new Guide()
{
AuthorId = guideModel.Author,
Content = guideModel.Content,
GameId = guideModel.Game,
Name = guideModel.Name,
Created = DateTime.Now
};
try
{
_guideRepo.Add(guide);
}
catch (Exception e)
{
result.Error = e.Message;
}
return(result);
}
private void GuidePanel_Load(object sender, EventArgs e)
{
try
{
_inLoad = true;
Cursor.Current = Cursors.WaitCursor;
_model = new GuideModel();
_controller = new GuideController(_model);
ChannelType channelType = ChannelType.Television;
if (MainForm.Session.ContainsKey(SessionKey.ChannelType))
{
channelType = (ChannelType)MainForm.Session[SessionKey.ChannelType];
}
_controller.Initialize(channelType, 24, ArgusTV.WinForms.Controls.EpgControl.EpgHoursOffset, "All Channels");
_channelTypeComboBox.SelectedIndex = (int)_model.ChannelType;
_groupsBindingSource.DataSource = _model.ChannelGroups;
_channelGroupsComboBox.DisplayMember = "GroupName";
_channelGroupsComboBox.ValueMember = "ChannelGroupId";
if (MainForm.Session.ContainsKey(SessionKey.ChannelGroupId))
{
_channelGroupsComboBox.SelectedValue = (Guid)MainForm.Session[SessionKey.ChannelGroupId];
}
DateTime guideDate = GetCurrentGuideDate();
if (MainForm.Session.ContainsKey(SessionKey.GuideDate))
{
guideDate = (DateTime)MainForm.Session[SessionKey.GuideDate];
}
_gotoNowTime = true;
_guideDatePicker.Value = guideDate;
RefreshEpg(true);
}
catch (Exception ex)
{
MessageBox.Show(this, ex.Message, null, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
finally
{
Cursor.Current = Cursors.Default;
_inLoad = false;
}
}
public async Task <IActionResult> UpdateGuide(int id, GuideModel guideModel)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var result = await _guideService.UpdateGuide(id, guideModel);
if (result.Error != null)
{
return(BadRequest(result));
}
return(Ok(result));
}
public void RefreshEpg(GuideModel model)
{
_model = model;
_channelCells.Clear();
int top = 0;
foreach (Channel channel in _model.Channels)
{
top = CreateChannelCell(channel, top);
}
this.Height = top;
this.Refresh();
}
public void RefreshEpg(GuideModel model)
{
_model = model;
_guideProgramCells.Clear();
int top = 0;
foreach (Channel channel in _model.Channels)
{
top = CreateEpgChannelCells(channel, top);
}
this.Width = (int)(5760 * _widthFactor);
this.Height = top;
this.Refresh();
}
public async void ShouldAddGuideIfDataCorrect()
{
var guideModel = new GuideModel();
var repo = new Mock <IRepository <Guide> >();
var gameRepo = new Mock <IRepository <Game> >();
var userRepo = new Mock <IRepository <User> >();
var reviewRepo = new Mock <IRepository <GuideReview> >();
userRepo.Setup(x => x.Exists(It.IsAny <Expression <Func <User, bool> > >())).Returns(Task.FromResult(true));
gameRepo.Setup(x => x.Exists(It.IsAny <Expression <Func <Game, bool> > >())).Returns(Task.FromResult(true));
var guideService = new GuideService(repo.Object, gameRepo.Object, userRepo.Object, reviewRepo.Object);
var guideController = new GuideController(guideService);
var result = await guideController.AddGuide(guideModel);
var OkResult = Assert.IsType <OkObjectResult>(result);
var ResultValue = Assert.IsAssignableFrom <ResultDto <BaseDto> >(OkResult.Value);
Assert.Null(ResultValue.Error);
}
public async void ShouldNotAddGuideIfAuthorNotFound()
{
var guideModel = new GuideModel();
var repo = new Mock <IRepository <Guide> >();
var gameRepo = new Mock <IRepository <Game> >();
var userRepo = new Mock <IRepository <User> >();
var reviewRepo = new Mock <IRepository <GuideReview> >();
userRepo.Setup(x => x.Exists(It.IsAny <Expression <Func <User, bool> > >())).Returns(Task.FromResult(false));
var guideService = new GuideService(repo.Object, gameRepo.Object, userRepo.Object, reviewRepo.Object);
var guideController = new GuideController(guideService);
var result = await guideController.AddGuide(guideModel);
var badRequest = Assert.IsType <BadRequestObjectResult>(result);
var errorResult = Assert.IsAssignableFrom <ResultDto <BaseDto> >(badRequest.Value);
string error = "Autor poradnika nie został odnaleziony";
Assert.Contains(error, errorResult.Error);
}
public IActionResult Register([FromBody] GuideModel obj)
{
var guide = new Guide
{
Address = obj.Address,
City = obj.City,
Email = obj.Email,
FirstName = obj.FirstName,
IdentityId = GetCurrentUserIdentityId(),
IsAdmin = false,
IsMember = false,
LastName = obj.LastName,
Notes = obj.Notes,
Phone = obj.Phone
};
unitOfWork.GuideRepository.Insert(guide);
unitOfWork.Commit();
//var accessToken = HttpContext.GetTokenAsync("access_token").Result;
return(new ObjectResult(guide.GuideId));
}
public static void ExportGuide()
{
GuideModel guideModel = new GuideModel();
List <string> list = guideModel.GetCsv();
string path = Application.dataPath + "/../csv2xlsx/war_guide.csv";;
if (File.Exists(path))
{
File.Delete(path);
}
FileStream fs = new FileStream(path, FileMode.CreateNew);
StreamWriter sw = new StreamWriter(fs);
for (int i = 0; i < list.Count; i++)
{
sw.WriteLine(list[i]);
}
sw.Close(); fs.Close();
UnityEngine.Debug.Log(path);
#if UNITY_EDITOR_OSX
string shell = Application.dataPath + "/../csv2xlsx/warguide_mac.sh";
System.Diagnostics.Process.Start("/bin/bash", shell);
#else
string shell = Application.dataPath + "/../csv2xlsx/warguide_win.bat";
string log = RunCmd(shell);
UnityEngine.Debug.Log(log);
#endif
}
public void RefreshEpg(GuideModel model)
{
_epgChannelsGridControl.RefreshEpg(model);
}
public void RefreshEpg(GuideModel model)
{
_epgProgramsGridControl.RefreshEpg(model);
}
public async Task <ActionResult> UpdateGuide(GuideModel updatedGuide) //? -> może być null
{
if (!LoginHelper.IsAuthenticated())
{
return(RedirectToAction("Login", "Account"));
}
else if (!LoginHelper.IsCurrentUserAdmin() && LoginHelper.GetCurrentUserId() != updatedGuide.GuideId)
{
return(RedirectToAction("Error", "Home", new { error = "Nie masz wystarczających uprawnień by zmieniać te dane" }));
}
else if (!LoginHelper.IsCurrentUserAdmin() && updatedGuide.IsAdmin == true)
{
return(RedirectToAction("Error", "Home", new { error = "Nie masz wystarczających uprawnień by nadawać prawa administratora" }));
}
else if (!LoginHelper.IsCurrentUserAdmin() && updatedGuide.IsMember == true &&
!LoginHelper.IsCurrentUserMember())
{
return(RedirectToAction("Error", "Home", new { error = "Nie masz wystarczających uprawnień by nadawać prawa członkowskie do grupy" }));
}
// add validation function
/*
* if (!DogHelpers.ValidateUpdateGuide(updatedGuide))
* return false;
*/
//client.BaseAddress = new Uri(url);
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
client.DefaultRequestHeaders.Authorization =
new AuthenticationHeaderValue("Bearer", LoginHelper.GetToken());
// dla put(update) i post(add):
//httpmethod.put i httpmethod.post
//message.Content = new StringContent(***object-json-serialized***,
// System.Text.Encoding.UTF8, "application/json");
HttpRequestMessage message = new HttpRequestMessage(HttpMethod.Put, client.BaseAddress + "guides/" + updatedGuide.GuideId.ToString());
/*var dog = new DogModel
* {
* DogID = updatedDog.DogID,
* Name = updatedDog.Name,
* DateOfBirth = updatedDog.DateOfBirth,
* Level = updatedDog.Level,
* Workmodes = updatedDog.Workmodes,
* Notes = updatedDog.Notes,
* // change in the same way as in add dogs
* GuideId = 1 //IT DOESNT WORK, IT SHOULD BE A REAL GUIDE, NOW SERVER JUST IGNORES GUIDE AND LEAVES THE OLD ONE UNCHANGED!
* };*/
var guideSerialized = JsonConvert.SerializeObject(updatedGuide);
message.Content = new StringContent(guideSerialized, System.Text.Encoding.UTF8, "application/json"); //dog serialized id.ToString()
HttpResponseMessage responseMessage = client.SendAsync(message).Result;
if (responseMessage.IsSuccessStatusCode) //200 OK
{
//wyswietlić informację
message.Dispose();
return(RedirectToAction("Guide", new { id = Int32.Parse(responseMessage.Content.ReadAsStringAsync().Result) }));
//wywolać metodę Dog zamiast zwracać true
}
else // wiadomosc czego się nie udało
{
message.Dispose();
ViewBag.Message = "Kod błędu:" + responseMessage.StatusCode;
return(View("Error"));
}
}
public static DateTime GetEpgEndTime(GuideModel model)
{
return(model.GuideDateTime.Date.AddDays(1).AddHours(EpgHoursOffset));
}
//metoda edycji poradnika
public async Task <ResultDto <BaseDto> > UpdateGuide(int id, GuideModel guideModel)
{
var result = new ResultDto <BaseDto>()
{
Error = null
};
//sprawdzam czy podany poradnik istnieje
var guide = await _guideRepo.GetSingleEntity(x => x.Id == id);
if (guide == null)
{
result.Error = "Nie odnaleziono wybranego poradnika";
return(result);
}
//sprawdzam czy użytkownik istnieje
bool userExists = await _userRepo.Exists(x => x.Id == guideModel.Author);
if (!userExists)
{
result.Error = "Autor poradnika nie został odnaleziony";
return(result);
}
//sprawdzam czy gra istnieje
bool gameExists = await _gameRepo.Exists(x => x.Id == guideModel.Game);
if (!gameExists)
{
result.Error = "Podana gra nie została znaleziona";
return(result);
}
//sprawdzam czy nowa nazwa poradnika nie jest juz w uzyciu
if (guide.Name != guideModel.Name && guideModel.Name != "null")
{
bool guideExists = await _guideRepo.Exists(x => x.Name == guideModel.Name && x.Id != id);
if (guideExists)
{
result.Error = "Podana nazwa jest już w użyciu";
return(result);
}
guide.Name = guideModel.Name;
}
if (guide.Content != guideModel.Content && guideModel.Content != "null")
{
guide.Content = guideModel.Content;
}
//aktualizuje poradnik
try
{
_guideRepo.Update(guide);
}
catch (Exception e)
{
result.Error = e.Message;
}
return(result);
}
public static DateTime GetEpgStartTime(GuideModel model)
{
return(model.GuideDateTime.Date.AddHours(EpgHoursOffset));
}
