public ActionResult GetWatchListSetting(int selectedItem) { WatchListDTO watchList = new WatchListDTO(); ShipperReturnByIdentity currentIdentity = GetValueFromIdentity(); var user = SignInManager.UserManager.FindById(currentIdentity.UserId); if (user != null) { watchList.UserEmail = user.Email; } watchList.RuleList = new List <WatchListRule>() { }; ViewBag.Pipeline = GetPipelines(); // pipelineService.GetAllPipelineList(GetCurrentCompanyID(),GetLoggedInUserId()); switch (selectedItem) { case 1: watchList.DatasetId = Enums.EnercrossDataSets.OACY; break; case 2: watchList.DatasetId = Enums.EnercrossDataSets.UNSC; break; case 3: watchList.DatasetId = Enums.EnercrossDataSets.SWNT; break; } return(PartialView(watchList)); }
public async Task GetAllWatchLists() { string url = ApiPaths.WATCH_LIST_ALL_PATH; Dictionary <string, string> queryParams = new Dictionary <string, string> { { "userId", this.TestWatchListCustom.PartitionKey } }; var response = await this.Consumer.ExecuteRequest(url, queryParams, null, Method.GET); Assert.True(response.Status == HttpStatusCode.OK); List <WatchListDTO> parsedResponse = JsonUtils.DeserializeJson <List <WatchListDTO> >(response.ResponseJson); List <WatchListEntity> userWatchLists = this.AllWatchListsFromDBCustom.Where(w => w.PartitionKey == this.TestWatchListCustom.PartitionKey).ToList(); userWatchLists.AddRange(this.AllWatchListsFromDBPredefined); foreach (WatchListEntity entity in userWatchLists) { WatchListDTO parsedMatch = parsedResponse.Where(p => p.Id == entity.Id).FirstOrDefault(); entity.ShouldBeEquivalentTo(parsedMatch, o => o .ExcludingMissingMembers() .Excluding(e => e.AssetIds) .Excluding(e => e.ReadOnly)); foreach (string assetId in parsedMatch.AssetIds) { entity.AssetIDsList.Should().Contain(assetId); } } }
public async Task GetAllWatchListsPredefined() { string url = ApiPaths.WATCH_LIST_PREDEFINED_PATH; var response = await this.Consumer.ExecuteRequest(url, Helpers.EmptyDictionary, null, Method.GET); Assert.True(response.Status == HttpStatusCode.OK); List <WatchListDTO> parsedResponse = JsonUtils.DeserializeJson <List <WatchListDTO> >(response.ResponseJson); foreach (WatchListEntity entity in this.AllWatchListsFromDBPredefined) { WatchListDTO parsedMatch = parsedResponse.Where(p => p.Id == entity.Id).FirstOrDefault(); entity.ShouldBeEquivalentTo(parsedMatch, o => o .ExcludingMissingMembers() .Excluding(e => e.AssetIds) .Excluding(e => e.ReadOnly)); Assert.True(parsedMatch.ReadOnly); entity.AssetIDsList.Should().HaveSameCount(parsedMatch.AssetIds); foreach (string assetId in entity.AssetIDsList) { parsedMatch.AssetIds.Should().Contain(assetId); } } }
public async Task GetSingleWatchListsCustom() { string url = ApiPaths.WATCH_LIST_CUSTOM_PATH + "/" + this.TestWatchListCustom.Id; Dictionary <string, string> queryParams = new Dictionary <string, string> { { "userId", this.TestWatchListCustom.PartitionKey } }; var response = await this.Consumer.ExecuteRequest(url, queryParams, null, Method.GET); Assert.True(response.Status == HttpStatusCode.OK); WatchListDTO parsedResponse = JsonUtils.DeserializeJson <WatchListDTO>(response.ResponseJson); this.TestWatchListCustom.ShouldBeEquivalentTo(parsedResponse, o => o .ExcludingMissingMembers() .Excluding(e => e.AssetIds) .Excluding(e => e.ReadOnly)); Assert.False(parsedResponse.ReadOnly); foreach (string assetId in this.TestWatchListCustom.AssetIDsList) { parsedResponse.AssetIds.Should().Contain(assetId); } }
public ActionResult Index(int watchListId = 0) { if (TempData["Msg"] != null) { ViewBag.Status = TempData["Msg"] + ""; } WatchListDTO watchList = new WatchListDTO(); if (watchListId != 0) { ViewBag.EditFlag = watchListId + ""; RestRequest request = new RestRequest("GetWatchListById/" + watchListId, Method.GET); IRestResponse <WatchListDTO> response = client.Execute <WatchListDTO>(request); if (response.IsSuccessful) { watchList.DatasetId = response.Data.DatasetId; } watchList.id = watchListId; } watchList.RuleList = new List <WatchListRule>() { new WatchListRule() { } }; return(View(watchList)); }
public ActionResult AddRuleSettings(int datasetId) { WatchListDTO watchList = new WatchListDTO(); switch (datasetId) { case 1: watchList.DatasetId = Enums.EnercrossDataSets.OACY; break; case 2: watchList.DatasetId = Enums.EnercrossDataSets.UNSC; break; case 3: watchList.DatasetId = Enums.EnercrossDataSets.SWNT; break; } RestRequest requestForProp = new RestRequest("GetPropertiesByDataSet", Method.GET); requestForProp.AddQueryParameter("dataset", watchList.DatasetId.ToString()); requestForProp.JsonSerializer = NewtonsoftJsonSerializer.Default; IRestResponse <List <WatchListProperty> > responseForProp = client.Execute <List <WatchListProperty> >(requestForProp); List <WatchListProperty> properties = responseForProp.Data != null ? responseForProp.Data : new List <WatchListProperty>(); //IWatchlistService.GetPropertiesByDataSet(watchList.DatasetId); ViewBag.Properties = properties; if (properties.Count > 0) { ViewBag.Operators = properties.FirstOrDefault().Operators; } else { ViewBag.Operators = new List <WatchListOperator>(); } List <WatchListRule> newwatchRule = new List <WatchListRule>() { new WatchListRule() { } }; watchList.RuleList = newwatchRule; // var pipelineList = pipelineService.GetAllPipelineList(GetCurrentCompanyID(),GetLoggedInUserId()); ViewBag.PipelineId = GetPipelines(); ViewBag.LocationIdentifier = new List <LocationsDTO>(); if (watchList.DatasetId == Enums.EnercrossDataSets.OACY) { return(PartialView("OacyRuleSettings", watchList)); } else { return(PartialView(watchList)); } }
public IHttpActionResult UpdateWatchList([FromBody] WatchListDTO watchListDto) { bool result = false; if (watchListDto != null) { WatchlistService.UpdateWatchList(watchListDto); result = true; } return(Json(result)); }
public async Task DeletePredefinedWatchList() { WatchListDTO TestWatchListPredefinedDelete = await CreateTestWatchList(); string url = ApiPaths.WATCH_LIST_PREDEFINED_PATH + "/" + TestWatchListPredefinedDelete.Id; var response = await this.Consumer.ExecuteRequest(url, Helpers.EmptyDictionary, null, Method.DELETE); Assert.True(response.Status == HttpStatusCode.NoContent); WatchListEntity entity = await this.WatchListRepository.TryGetAsync("PublicWatchList", TestWatchListPredefinedDelete.Id) as WatchListEntity; Assert.Null(entity); }
public ActionResult Index(WatchListDTO watchlist, string Save) { var msg = Validation(watchlist); if (string.IsNullOrEmpty(msg)) { ShipperReturnByIdentity currentIdentity = GetValueFromIdentity(); watchlist.UserId = currentIdentity.UserId; var url = BaseUrl(); watchlist.MoreDetailURLinAlert = url; if (Save == "Update") { // Code for Update RestRequest request = new RestRequest("UpdateWatchList", Method.POST); request.JsonSerializer = NewtonsoftJsonSerializer.Default; request.AddJsonBody(watchlist); IRestResponse <bool> response = client.Execute <bool>(request); return(RedirectToAction("List")); } else { //Code for Save RestRequest request = new RestRequest("SaveWatchList", Method.POST); request.JsonSerializer = NewtonsoftJsonSerializer.Default; request.AddJsonBody(watchlist); IRestResponse <bool> response = client.Execute <bool>(request); bool save = response.Data; if (save != false) { TempData["Msg"] = "Data saved successfully"; } else { TempData["Msg"] = "Data saving failed"; } return(RedirectToAction("Index", new { watchListId = 0 })); } } else { TempData["Msg"] = "Action failed." + msg; return(RedirectToAction("Index", new { watchListId = 0 })); } }
public async Task DeleteCustomWatchList() { WatchListDTO TestWatchListCustomDelete = await CreateTestWatchList(TestAccountId); string url = ApiPaths.WATCH_LIST_CUSTOM_PATH + "/" + TestWatchListCustomDelete.Id; Dictionary <string, string> queryParams = new Dictionary <string, string> { { "userId", this.TestAccountId } }; var response = await this.Consumer.ExecuteRequest(url, queryParams, null, Method.DELETE); Assert.True(response.Status == HttpStatusCode.NoContent); WatchListEntity entity = await this.WatchListRepository.TryGetAsync(this.TestAccountId, TestWatchListCustomDelete.Id) as WatchListEntity; Assert.Null(entity); }
public async Task <WatchListDTO> CreateTestWatchList(string clientId = null) { string url = ApiPaths.WATCH_LIST_BASE_PATH; Dictionary <string, string> queryParams = new Dictionary <string, string>(); bool readOnlyValue = true; if (clientId == null) { url += "/predefined"; } else { url += "/custom"; queryParams.Add("userId", clientId); readOnlyValue = false; } WatchListEntity tempalteEntity = EnumerableUtils.PickRandom(AllWatchListsFromDB); WatchListDTO createDTO = new WatchListDTO() { Id = tempalteEntity.Id, Name = tempalteEntity.Name, ReadOnly = tempalteEntity.ReadOnly, Order = tempalteEntity.Order, AssetIds = tempalteEntity.AssetIDsList }; createDTO.Id += Helpers.Random.Next(1000, 9999).ToString() + GlobalConstants.AutoTest; createDTO.Name += Helpers.Random.Next(1000, 9999).ToString() + GlobalConstants.AutoTest; createDTO.ReadOnly = readOnlyValue; string createParam = JsonUtils.SerializeObject(createDTO); var response = await Consumer.ExecuteRequest(url, queryParams, createParam, Method.POST); if (response.Status != HttpStatusCode.Created) { return(null); } AddOneTimeCleanupAction(async() => await DeleteTestWatchList(createDTO.Id, clientId)); return(createDTO); }
public async Task UpdateCustomWatchList() { string url = ApiPaths.WATCH_LIST_CUSTOM_PATH; WatchListDTO TestWatchListCustomUpdate = await CreateTestWatchList(TestAccountId); Dictionary <string, string> queryParams = new Dictionary <string, string> { { "userId", this.TestAccountId } }; WatchListDTO updateWatchList = new WatchListDTO() { Id = TestWatchListCustomUpdate.Id, Name = TestWatchListCustomUpdate.Name + Helpers.Random.Next(1000, 9999).ToString() + GlobalConstants.AutoTest, Order = Helpers.Random.Next(1, 100), ReadOnly = TestWatchListCustomUpdate.ReadOnly, AssetIds = TestWatchListCustomUpdate.AssetIds }; updateWatchList.AssetIds.Add("AutoTest"); string updateParam = JsonUtils.SerializeObject(updateWatchList); var response = await this.Consumer.ExecuteRequest(url, queryParams, updateParam, Method.PUT); Assert.True(response.Status == HttpStatusCode.NoContent); WatchListEntity entity = await this.WatchListRepository.TryGetAsync(this.TestAccountId, updateWatchList.Id) as WatchListEntity; Assert.NotNull(entity); entity.ShouldBeEquivalentTo(updateWatchList, o => o .ExcludingMissingMembers() .Excluding(e => e.AssetIds) .Excluding(e => e.ReadOnly)); entity.AssetIDsList.Should().HaveSameCount(updateWatchList.AssetIds); foreach (string assetId in entity.AssetIDsList) { updateWatchList.AssetIds.Should().Contain(assetId); } }
public async Task CreatePredefinedWatchList() { WatchListDTO createdDTO = await this.CreateTestWatchList(); Assert.NotNull(createdDTO); WatchListEntity entity = await this.WatchListRepository.TryGetAsync("PublicWatchList", createdDTO.Id) as WatchListEntity; Assert.NotNull(entity); entity.ShouldBeEquivalentTo(createdDTO, o => o .ExcludingMissingMembers() .Excluding(e => e.AssetIds) .Excluding(e => e.ReadOnly)); entity.AssetIDsList.Should().HaveSameCount(createdDTO.AssetIds); foreach (string assetId in entity.AssetIDsList) { createdDTO.AssetIds.Should().Contain(assetId); } }
public async Task GetSingleWatchListsPredefined() { string url = ApiPaths.WATCH_LIST_PREDEFINED_PATH + "/" + this.TestWatchListPredefined.Id; var response = await this.Consumer.ExecuteRequest(url, Helpers.EmptyDictionary, null, Method.GET); Assert.True(response.Status == HttpStatusCode.OK); WatchListDTO parsedResponse = JsonUtils.DeserializeJson <WatchListDTO>(response.ResponseJson); this.TestWatchListPredefined.ShouldBeEquivalentTo(parsedResponse, o => o .ExcludingMissingMembers() .Excluding(e => e.AssetIds) .Excluding(e => e.ReadOnly)); Assert.True(parsedResponse.ReadOnly); this.TestWatchListPredefined.AssetIDsList.Should().HaveSameCount(parsedResponse.AssetIds); foreach (string assetId in this.TestWatchListPredefined.AssetIDsList) { parsedResponse.AssetIds.Should().Contain(assetId); } }
public async Task <WatchListDTO> UpdateWatchlistItem(string id, WatchListDTO watchListDTO) { if (watchListDTO == null) { throw new ArgumentNullException(nameof(watchListDTO)); } try { WatchList watchlist = await _context.WatchLists .FirstOrDefaultAsync(w => w.UserId == id && w.MovieId == watchListDTO.MovieId).ConfigureAwait(false); watchlist.Status = getStatus(watchListDTO.Status); watchlist.Score = watchListDTO.Score; await _context.SaveChangesAsync().ConfigureAwait(false); } catch (DbUpdateConcurrencyException) { if (await UserExists(id).ConfigureAwait(false) == false) { return(null); } else { throw; } } return(new WatchListDTO() { UserId = id, MovieId = watchListDTO.MovieId, Status = watchListDTO.Status, Score = watchListDTO.Score }); }
public string Validation(WatchListDTO watchlist) { string msg = string.Empty; if (watchlist.DatasetId == 0) { return("Please, Select DataSet for watchlist."); } if (string.IsNullOrEmpty(watchlist.ListName) || string.IsNullOrWhiteSpace(watchlist.ListName)) { return("Please, Eneter watchLlist Name."); } if (watchlist.RuleList == null || watchlist.RuleList.Count == 0) { return("Please, Select at least one Rule for watchlist."); } if (watchlist.RuleList.Count > 0) { foreach (var item in watchlist.RuleList) { if (item.PropertyId == 0 && watchlist.DatasetId == EnercrossDataSets.SWNT) { continue; } if (item.PropertyId == 0) { return("Please, select Column for watchlist Rule."); } if (watchlist.DatasetId != EnercrossDataSets.OACY) { if (item.ComparatorsId == 0) { return("Please, select condition for watchlist Rule"); } } if (string.IsNullOrEmpty(item.value) || string.IsNullOrWhiteSpace(item.value)) { return("Please, enter value for rule of watchlist."); } try { RestRequest requestForProp = new RestRequest("GetPropertyById", Method.GET); requestForProp.AddQueryParameter("propertyId", item.PropertyId.ToString()); IRestResponse <WatchListProperty> responseForProp = client.Execute <WatchListProperty>(requestForProp); var prop = responseForProp.Data; if (prop.Datatype == "decimal") { var dec = decimal.Parse(item.value); } if (prop.Datatype == "long") { var lon = long.Parse(item.value); } if (prop.Datatype == "DateTime") { var dat = DateTime.ParseExact(item.value, "MM/dd/yyyy", CultureInfo.InvariantCulture); } } catch (Exception ex) { return("Please, Enter Value in Correct Format. Don't use any special character in value."); } } } return(msg); }
public async Task <ActionResult <WatchListDTO> > UpdateWatchlistItem(string id, WatchListDTO watchListDTO) { var watchlistResult = await _userRepository.UpdateWatchlistItem(id, watchListDTO).ConfigureAwait(false); if (watchlistResult == null) { return(NotFound()); } return(watchlistResult); }