public List <Models.Aggregate> GetVisitsByDay(Models.Filter filter)
{
string sqlSelect = "select cast(StartTime as date) as [Date], count(*) as [Count], null as Location from Analytics_Visits";
string sqlGroupBy = "group by cast(StartTime as date)";
return(GetAggregates(filter, sqlSelect, sqlGroupBy));
}
public static List<BTNster.Models.Filter> GetFilters(int FilterID)
{
using (BTNsterEntities db = new BTNsterEntities())
{
List<Filter> filters = db.Filter.Where(x => x.FilterID == FilterID).ToList();
List<BTNster.Models.Filter> filterList = new List<Models.Filter>();
foreach (Filter filter in filters)
{
BTNster.Models.Filter newFilter = new Models.Filter()
{
DownloadBetterReleases = filter.DownloadBetterReleases,
EndDate = filter.EndDate,
FilterName = filter.FilterTitle,
RememberHistory = filter.RememberHistory,
SceneNo = filter.SceneNo,
SceneYes = filter.SceneYes,
StartDate = filter.StartDate,
};
filterList.Add(newFilter);
}
return filterList;
}
}
public async Task <List <T> > List([FromQuery] Models.Filter filters)
{
var sssssss = _entity;
var aaa = Request.HttpContext;
return(await _service.GetList(filters));
}
public IHttpActionResult Query([FromBody] Models.Filter filter)
{
if (filter != null && (!string.IsNullOrEmpty(filter.Title) || filter.YearOfRelease.HasValue || filter.Genres?.Count > 0))
{
List <Models.Movie> movies = db.Movies.Where(m => ((!string.IsNullOrEmpty(filter.Title) && m.Title.Contains(filter.Title)) || string.IsNullOrEmpty(filter.Title)) &&
((filter.YearOfRelease.HasValue && m.YearOfRelease == filter.YearOfRelease.Value) || !filter.YearOfRelease.HasValue) &&
((filter.Genres != null && filter.Genres.Contains(m.Genre)) || filter.Genres == null || filter.Genres.Count == 0))
.Select(m => new Models.Movie()
{
Id = m.Id,
Title = m.Title,
RunningTime = m.RunningTime,
YearOfRelease = m.YearOfRelease,
AverageRating = db.UserMovieRatings.Count(mr => mr.MovieId == m.Id) > 0 ? RoundToPointFive((float)db.UserMovieRatings.Where(mr => mr.MovieId == m.Id).Average(mr => mr.Rating)) : (float?)null
}).ToList();
if (movies?.Count > 0)
{
return(Ok(movies));
}
else
{
return(NotFound());
}
}
else
{
return(BadRequest());
}
}
public ActionResult DeleteConfirmed(string id)
{
Models.Filter filter = db.Filter.Find(id);
db.Filter.Remove(filter);
db.SaveChanges();
return(RedirectToAction("Index"));
}
Models.Filter SetFilterDefaults(Models.Filter filter)
{
if (!String.IsNullOrEmpty(SiteName))
{
filter.Website = SiteName;
}
return(filter);
}
public List <Models.Aggregate> GetVisitorsByDay(Models.Filter filter)
{
string sqlSelect = @"select StartTime as [Date], count(*) as [Count], null as Location from (
select distinct cast(StartTime as date) as [StartTime], IpAddress, Website from Analytics_Visits
) drv" ;
string sqlGroupBy = "group by StartTime";
return(GetAggregates(filter, sqlSelect, sqlGroupBy));
}
public ActionResult DeleteConfirmed(int id)
{
Models.Filter filter = db.Filters.Find(id);
//db.Filters.Remove(filter);
filter.Enable = false;
db.Entry(filter).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
public static void AddFilter(Models.Filter filter)
{
List <Models.Filter> Filters = GetFilter();
Filters.Add(filter);
using var writer = File.CreateText(ConfigGetter.GetFilterPath());
writer.Write(JsonConvert.SerializeObject(Filters, Formatting.Indented));
}
public RepositoryFilter ConvertToRepositoryModel(Models.Filter data)
{
return(new RepositoryFilter
{
PageSize = data.PageSize,
Offset = data.Offset,
SortColumn = data.SortColumn,
SortDirection = data.SortDirection
});
}
public ActionResult Edit([Bind(Include = "ID,Namjestaj,Parking,WiFi,Lift,Klima,Balkon,Novogradnja,Alarm,Videonadzor,TV")] Models.Filter filter)
{
if (ModelState.IsValid)
{
db.Entry(filter).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(filter));
}
// GET: Filters/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Models.Filter filter = db.Filters.Include(f => f.Category).Include(f => f.Type).Where(x => x.FilterID == id).SingleOrDefault();
if (filter == null)
{
return(HttpNotFound());
}
return(View(filter));
}
// GET: Filters/Delete/5
public ActionResult Delete(string id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Models.Filter filter = db.Filter.Find(id);
if (filter == null)
{
return(HttpNotFound());
}
return(View(filter));
}
public SearchPage()
{
InitializeComponent();
DateTime presetDate = DateTime.Now;
// If we're over the hump we'll set the start point at the first of this month.
if (presetDate.Day >= 15)
{
presetDate = presetDate.AddDays((presetDate.Day - 1) * -1);
}
else
{
// We'll set the start at the 15th of the last month.
// (except if this is January)
if (presetDate.Month == 1)
{
presetDate = new DateTime(presetDate.Year - 1, 12, 15);
}
else
{
presetDate = new DateTime(presetDate.Year, presetDate.Month - 1, 15);
}
}
// Pre-set the date search for the user
DateStart.Date = presetDate;
// Do we have filters set?
Models.Filter setFilter = Settings.Filter;
currentFilter = setFilter;
LoadFilters();
/* Prime neighborhoods */
foreach (Neighborhood hood in Global.Neighborhoods)
{
Neighborhood.Items.Add(hood.Name);
}
// If user has one primary neighborhood then we'll autofill the neighborhood search to
// make life easier for them.
if (Global.Neighborhoods.Where(p => p.Selected).Count() == 1)
{
int index = Neighborhood.Items.IndexOf(Global.Neighborhoods.Where(p => p.Selected).FirstOrDefault().Name);
Neighborhood.SelectedIndex = index;
}
UpdateFilters();
}
IQueryable <Models.Visit> FilteredVisits(Models.Filter filter)
{
DateTime startD = filter.StartDate.HasValue ? filter.StartDate.Value : DateTime.Now.AddDays(-65);
DateTime endD = filter.EndDate.HasValue ? filter.EndDate.Value.Date.AddDays(1) : DateTime.Now;
var visits = db.Analytics_Visits.Where(v =>
v.StartTime > startD &&
v.StartTime < endD &&
v.Website == filter.Website &&
(filter.Location == null || filter.Location == v.Location) &&
(filter.Visitor == null || filter.Visitor == v.IpAddress)
);
return(visits);
}
// GET: Filters/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Models.Filter filter = db.Filters.Find(id);
if (filter == null)
{
return(HttpNotFound());
}
ViewBag.CategoryID = new SelectList(db.Categories.Where(x => x.Enable == true), "CategoryID", "Name", filter.CategoryID);
ViewBag.TypeID = new SelectList(db.Types.Where(x => x.Enable == true), "TypeID", "Name", filter.TypeID);
return(View(filter));
}
public ActionResult Create([Bind(Include = "FilterID,Description,Place,Detail,CategoryID,TypeID")] Models.Filter filter)
{
if (ModelState.IsValid)
{
filter.Enable = true;
filter.CreatedOn = DateTime.Today;
filter.CreatedBy = Convert.ToInt32(Session["UserID"]);
db.Filters.Add(filter);
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.CategoryID = new SelectList(db.Categories, "CategoryID", "Name", filter.CategoryID);
ViewBag.TypeID = new SelectList(db.Types, "TypeID", "Name", filter.TypeID);
return(View(filter));
}
public void TestQuery_ActionGenre_Title_Year_NotFound()
{
var controller = new MoviesService.Controllers.MoviesController(new TestMoviesServiceContext());
Models.Filter filter = new Models.Filter
{
Genres = new List <string>()
{
"Action"
},
Title = "Fallout",
YearOfRelease = 2008
};
var result = controller.Query(filter);
Assert.IsInstanceOfType(result, typeof(NotFoundResult));
}
public ActionResult MostViewed(Models.Filter filter)
{
int itemCount = 20;
filter = SetFilterDefaults(filter);
var data = FilteredVisits(filter).GroupBy(v => v.Location).Select(g => new Models.Aggregate()
{
Location = g.Key, Count = g.Count()
}).OrderByDescending(a => a.Count).Take(itemCount).ToList();
Models.CurrentList <Models.Aggregate> model = new Models.CurrentList <Models.Aggregate>()
{
Title = "Most Viewed", Filter = filter, Data = data
};
return(FindView("AggregatesList", model));
}
// GET: CartaCreditoMVC
public ActionResult Index(string id = "")
{
Models.Filter filter = new Models.Filter();
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(String.Concat(ConfigurationSettings.AppSettings["URLCarta"], "/List"));
HttpWebResponse response;
StreamWriter sw;
StreamReader sr;
string strJSON = "";
clsJSONFormatter formatter = new clsJSONFormatter();
List <CartaCredito> carta = new List <CartaCredito>();
int count = 0;
if (Session["Filters"] != null || id != "")
{
if (Session["Filters"] != null)
{
filter = (Models.Filter)Session["Filters"];
filter.IdUser = id;
}
else
{
filter.IdUser = id;
Session.Add("Filters", filter);
}
strJSON = formatter.ClasstoJSON(filter);
request.ContentType = "application/json";
request.Accept = "application/json";
request.Method = "POST";
request.KeepAlive = false;
sw = new StreamWriter(request.GetRequestStream());
sw.Write(strJSON);
sw.Flush();
response = (HttpWebResponse)request.GetResponse();
sr = new StreamReader(response.GetResponseStream());
carta = (List <CartaCredito>)formatter.JSONtoClass(sr.ReadToEnd(), new List <CartaCredito>());
}
return(View(carta));
}
public void TestQuery_ActionGenre()
{
var controller = new MoviesService.Controllers.MoviesController(new TestMoviesServiceContext());
Models.Filter filter = new Models.Filter
{
Genres = new List <string>()
{
"Action"
}
};
var result = controller.Query(filter);
Assert.IsInstanceOfType(result, typeof(OkNegotiatedContentResult <List <Models.Movie> >));
var resultMovies = result as OkNegotiatedContentResult <List <Models.Movie> >;
Assert.AreEqual(3, resultMovies.Content.Count);
}
/// <summary>
/// only for test
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public async Task <List <User> > GetList(Models.Filter model)
{
return(new List <User>
{
new User {
ID = 1,
Firstname = "SaeedSafaee",
Email = "*****@*****.**"
},
new User {
ID = 2,
Firstname = "al",
Email = "*****@*****.**"
},
new User {
ID = 3,
Firstname = "test",
Email = "*****@*****.**"
},
});
}
public ActionResult Edit(Models.Filter filter)
{
if (!filter.HasSection)
{
ViewBag.Message = "Необходимо выбрать раздел";
return(View(filter));
}
if (filter.ID == 0)
{
db.Filters.InsertOnSubmit(filter);
}
else
{
var dbf = db.Filters.First(x => x.ID == filter.ID);
dbf.SelectedSection = filter.SelectedSection;
dbf.Visible = filter.Visible;
}
db.SubmitChanges();
return(RedirectToAction("Index"));
}
public ActionResult Index(Models.Filter filter)
{
filter = SetFilterDefaults(filter);
List <string> websites = null;
if (String.IsNullOrEmpty(filter.Website))
{
websites = db.Analytics_Visits.Select(v => v.Website).Distinct().ToList();
}
else
{
websites = db.Analytics_Visits.Where(v => v.Website == filter.Website).Select(v => v.Website).Distinct().ToList();
}
Models.CurrentList <string> model = new Models.CurrentList <string>()
{
Filter = filter, Data = websites
};
return(FindView("Index", model));
}
public ActionResult Aggregates_Visits(Models.Filter filter)
{
filter = SetFilterDefaults(filter);
if (null == filter.EndDate)
{
filter.EndDate = DateTime.Now;
}
if (null == filter.StartDate)
{
filter.StartDate = filter.EndDate.Value.AddDays(-35);
}
var aggregates = db.GetVisitsByDay(filter);
Models.CurrentList <Models.Aggregate> model = new Models.CurrentList <Models.Aggregate>()
{
Title = "Page Views", Filter = filter, Data = aggregates
};
return(FindView("Aggregates", model));
}
public async Task <ActionResult> GetByOption(Models.Filter filter)
{
var result = await _client.PostAsync("api/PolicyAPI/filtered"
, Serializer.ToStringContent(filter));
if (result.IsSuccessStatusCode)
{
ViewBag.updateDate = filter.updateDate;
ViewBag.name = filter.name;
ViewBag.surname = filter.surname;
ViewBag.state = filter.state;
ViewBag.objectName = filter.objectName;
ViewBag.nameSelected = filter.nameSelected;
if (filter.nameSelected)
{
var content = await result.Content
.ReadAsAsync <List <Owner> >();
if (content != null)
{
return(PartialView("~/Views/Policy/_ownerCollection.cshtml"
, content));
}
}
else
{
var content = await result.Content
.ReadAsAsync <List <PolicyDtoCreated> >();
if (content != null)
{
return(PartialView("~/Views/Policy/_policyCollection.cshtml"
, content));
}
}
}
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
public IEnumerable <CustomerViewModel> GetAll(Models.Filter filter, int page, int size)
{
if (size <= 0 || size > 20)
{
size = 20;
}
if (page == 0)
{
page = 1;
}
return(_mapper.Map <List <Customer>, IEnumerable <CustomerViewModel> >(
_unitOfWork.CustomerRepository.GetAll()
.Where(x => (string.IsNullOrEmpty(filter.Email) || x.Email.ToLower().Contains(filter.Email.ToLower())) &&
(string.IsNullOrEmpty(filter.Country) || x.Country.ToLower().Contains(filter.Country.ToLower())) &&
(string.IsNullOrEmpty(filter.City) || x.City.ToLower().Contains(filter.City.ToLower())) &&
(string.IsNullOrEmpty(filter.Name) || x.FirstName.ToLower().Contains(filter.Name.ToLower())) ||
(string.IsNullOrEmpty(filter.Name) || x.LastName.ToLower().Contains(filter.Name.ToLower()))
)
.Skip((page - 1) * size)
.Take(size)
.ToList()));
}
public IEnumerable <CartaCredito> Post([FromBody] Models.Filter value)
{
List <tbCartaCredito> readCarta = new List <tbCartaCredito>();
clsCRUDConsorcio CRUD = new clsCRUDConsorcio();
List <CartaCredito> listCarta = new List <CartaCredito>();
readCarta = CRUD.readCartasCredito(value.ValorCreditoDe, value.ValorCreditoAte, value.IdUser, value.StatusCarta, value.RemoveProposta);
if (readCarta.Count > 0)
{
for (int i = 0; i < readCarta.Count; i++)
{
CartaCredito carta = new CartaCredito();
carta.Id = readCarta[i].cd_cartacredito;
carta.IdVendedor = readCarta[i].cd_vendedor;
carta.AdmConsorcio = readCarta[i].cd_admconsorcio;
carta.TipoConsorcio = readCarta[i].cd_tipoconsorcio;
carta.Cidade = readCarta[i].de_cidade;
carta.Honorarios = readCarta[i].nu_honorarios;
carta.Indexador = readCarta[i].de_indexador;
carta.QtdParcelas = readCarta[i].nu_qtd_parcelas;
carta.SaldoCarta = readCarta[i].nu_saldocarta;
carta.StatusCarta = readCarta[i].cd_statuscarta;
carta.TaxaJuros = readCarta[i].nu_taxajuros;
carta.UF = readCarta[i].de_uf;
carta.ValorCredito = readCarta[i].nu_valorcredito;
carta.ValorEntrada = readCarta[i].nu_valorentrada;
carta.ValorParcela = readCarta[i].nu_valorparcela;
listCarta.Add(carta);
carta = null;
}
}
return(listCarta);
}
protected async override void OnAppearing()
{
base.OnAppearing();
// Is a primary location already set?
if (Math.Abs(Settings.PrimaryLat) > Double.Epsilon)
{
labelLocationHint.IsVisible = false;
checkImage.IsVisible = true;
labelLocation.Text = "Location is set";
}
// Get Filters from Settings
Models.Filter setFilter = Settings.Filter;
currentFilter = setFilter;
LoadFilters();
if (!_runOnce)
{
var b = await GetNeighborhoodSettings();
if (b)
{
NeighborhoodListView.ItemsSource = Global.Neighborhoods;
// Scroll the list to the first selected thing.
var firstSelected = Global.Neighborhoods.Where(p => p.Selected).FirstOrDefault();
if (firstSelected != null)
{
NeighborhoodListView.ScrollTo(firstSelected, ScrollToPosition.Start, false);
}
}
_runOnce = true;
}
}
private async Task LoadMovies()
{
try
{
IsBusy = true;
var movies = await MoviesService.GetWithGenresAndSourcesAsync(MovieSortOrder);
Movies = new ObservableCollection <MoviesItemViewModel>(movies.Select(m => CreateMoviesItemViewModel(m)));
if (MovieFilter == null)
{
Title = "Filme";
MovieFilter = Resolver.Resolve <IFilterService>().GetDefault();
}
if (MovieFilter != null)
{
Title = MovieFilter.Name;
try
{
Movies = new ObservableCollection <MoviesItemViewModel>(Movies.AsQueryable().Where(FilterBuilder <MoviesItemViewModel> .Ref.BuildFilter(MovieFilter)));
}
catch (Exception ex)
{
LogManager.GetCurrentClassLogger().Error(ex);
}
}
}
catch (Exception ex)
{
LogManager.GetCurrentClassLogger().Error(ex);
}
finally
{
IsBusy = false;
}
}
private FilterItemViewModel CreateFilterItemViewModel(Models.Filter filter)
{
return(new FilterItemViewModel(filter));
}
/// <summary>
/// Takes a list of filters given in their query format and converts them into a
/// list of Filter objects.
/// </summary>
/// <param name="filterStrings">The filters query string to create a list from</param>
/// <returns>A list of filters built off the query string</returns>
public static List<Filter> FilterQueryStringToList(String filterStrings)
{
List<Filter> filters = new List<Filter>();
if (filterStrings != null)
{
//fill filters with filters from filterStrings
foreach (string filterString in filterStrings.Split(new Char[] { '{', '}' })) //split into individual filter strings first
{
//split current filter string into a string array {targetFiled,value}
String[] currentFilterString = filterString.Split(new char[] { ',' }, 2);
if (currentFilterString.Length == 2 && Enum.IsDefined(typeof(Models.Field), currentFilterString[0]))
{
//get target field from Enum
Models.Field targetField = (Models.Field)Enum.Parse(typeof(Models.Field), currentFilterString[0]);
//build the current filter
Models.Filter filter = new Models.Filter(targetField, currentFilterString[1]);
//if the filter is not already in the filter list, add it.
if (!filters.Any(a => a.TargetField.Equals(filter.TargetField) && a.Value.Equals(filter.Value)))
{
filters.Add(filter);
}
}
}
}
return filters;
}
