public object Any(ClearCache request)
{
Cache.FlushAll();
PostServicesBase.PeriodicUpdateTableCaches(Db);
PostServicesBase.ClearOrganizationCache();
Cache.FlushAll();
return("OK");
}
public async Task <GetOrganizationMembersResponse> Get(GetOrganizationMembers request)
{
if (request.Id <= 0)
{
throw new ArgumentNullException(nameof(request.Id));
}
PostServicesBase.AssertCanViewOrganization(Db, request.Id, SessionAs <AuthUserSession>(), out _, out _);
return(new GetOrganizationMembersResponse
{
OrganizationId = request.Id,
Results = await Db.SelectAsync <OrganizationMember>(x => x.OrganizationId == request.Id),
});
}
private async Task <GetOrganizationResponse> GetOrganization(Organization organization)
{
PostServicesBase.AssertCanViewOrganization(Db, organization, SessionAs <AuthUserSession>(), out _);
var members = await Db.SelectAsync <OrganizationMember>(x => x.OrganizationId == organization.Id && (x.IsOwner || x.IsModerator));
return(new GetOrganizationResponse
{
Cache = Stopwatch.GetTimestamp(),
Id = organization.Id,
Slug = organization.Slug,
Organization = organization,
Labels = await Db.SelectAsync <OrganizationLabel>(x => x.OrganizationId == organization.Id),
Categories = (await Db.SelectAsync <Category>(x => x.OrganizationId == organization.Id && x.Deleted == null)).OrderBy(x => x.Name).ToList(),
Owners = members.Where(x => x.IsOwner).ToList(),
Moderators = members.Where(x => x.IsModerator).ToList(),
MembersCount = PostServicesBase.GetOrganizationMembersCount(organization.Id), //display only, can be stale
});
}
public object Any(HourlyTask request)
{
if (!request.Force)
{
return(new HourlyTaskResponse());
}
var updatedTechIds = Db.ExecuteSql("UPDATE page_stats AS p SET ref_id = t.id FROM technology AS t WHERE t.slug = p.ref_slug and p.ref_type = 'tech' AND ref_id = 0");
var updatedStackIds = Db.ExecuteSql("UPDATE page_stats AS p SET ref_id = t.id FROM technology_stack AS t WHERE t.slug = p.ref_slug and p.ref_type = 'stack' AND ref_id = 0");
var techFavs = Db.Dictionary <long, long>("SELECT technology_id, count(*) FROM user_favorite_technology GROUP BY technology_id");
foreach (var techFav in techFavs)
{
Db.ExecuteSql("UPDATE page_stats SET fav_count = @favCount WHERE ref_id = @refId and ref_type = 'tech'",
new { refId = techFav.Key, favCount = techFav.Value });
}
var stackFavs = Db.Dictionary <long, long>("SELECT technology_stack_id, count(*) FROM user_favorite_technology_stack GROUP BY technology_stack_id");
foreach (var stackFav in stackFavs)
{
Db.ExecuteSql("UPDATE page_stats SET fav_count = @favCount WHERE ref_id = @refId and ref_type = 'stack'",
new { refId = stackFav.Key, favCount = stackFav.Value });
}
PostServicesBase.PeriodicUpdateTableCaches(Db);
Any(new ClearCache());
return(new HourlyTaskResponse
{
Meta = new Dictionary <string, string>
{
{ "updatedTechIds", updatedTechIds.ToString() },
{ "updatedStackIds", updatedStackIds.ToString() },
{ "techFavsCount", techFavs.Count.ToString() },
{ "stackFavsCount", stackFavs.Count.ToString() },
}
});
}
public object Any(Overview request)
{
if (request.Reload)
{
Cache.FlushAll();
}
var topTechByCategory = GetTopTechByCategory();
var map = new Dictionary <string, List <TechnologyInfo> >();
foreach (var tech in topTechByCategory)
{
List <TechnologyInfo> techs = null;
var key = Enum.GetName(typeof(TechnologyTier), tech.Tier);
if (key != null && !map.TryGetValue(key, out techs))
{
map[key] = techs = new List <TechnologyInfo>();
}
techs?.Add(tech);
}
foreach (var tier in map.Keys)
{
var list = map[tier];
list.Sort((x, y) => y.StacksCount - x.StacksCount);
if (list.Count > 5)
{
list.RemoveRange(5, list.Count - 5);
}
}
var allOrgs = Db.Select <OrganizationInfo>(Db.From <Organization>()
.Where(g => g.Deleted == null));
var allOrgsMap = allOrgs.ToDictionary(x => x.Id);
var orgLabels = Db.Select <OrganizationLabel>();
foreach (var orgLabel in orgLabels)
{
if (allOrgsMap.TryGetValue(orgLabel.OrganizationId, out var org))
{
(org.Labels ?? (org.Labels = new List <LabelInfo>()))
.Add(orgLabel.ConvertTo <LabelInfo>());
}
}
var orgCategories = Db.Select <Category>(x => x.Deleted == null);
foreach (var category in orgCategories)
{
if (allOrgsMap.TryGetValue(category.OrganizationId, out var org))
{
(org.Categories ?? (org.Categories = new List <CategoryInfo>()))
.Add(category.ConvertTo <CategoryInfo>());
}
}
foreach (var entry in allOrgsMap)
{
var org = entry.Value;
org.MembersCount = PostServicesBase.GetOrganizationMembersCount(org.Id);
org.Categories?.Sort((x, y) => string.Compare(x.Name, y.Name, StringComparison.Ordinal));
}
var response = new OverviewResponse
{
Created = DateTime.UtcNow,
LatestTechStacks = Db.GetTechstackDetails(Db.From <TechnologyStack>().OrderByDescending(x => x.LastModified).Limit(20)),
TopUsers = Db.Select <UserInfo>(
@"select u.user_name as UserName, u.default_profile_url as AvatarUrl, COUNT(*) as StacksCount
from technology_stack ts
left join
user_favorite_technology_stack uf on (ts.id = uf.technology_stack_id)
left join
custom_user_auth u on (u.id = ts.owner_id::integer)
group by u.user_name, u.default_profile_url
having count(*) > 0
order by StacksCount desc
limit 20"),
TopTechnologies = topTechByCategory
.OrderByDescending(x => x.StacksCount)
.Take(50)
.ToList(),
PopularTechStacks = Db.Select(
Db.From <TechnologyStack>()
.Join <PageStats>((s, p) => s.Id == p.RefId && p.RefType == "stack")
.OrderByDescending <PageStats>(p => p.ViewCount)
.Limit(12)),
AllOrganizations = allOrgs,
TopTechnologiesByTier = map,
};
//Lighten payload
response.LatestTechStacks.Each(x => {
x.Details = x.DetailsHtml = null;
x.TechnologyChoices.Each(y => {
y.Description = null;
});
});
//Put TechStacks entry first to provide a first good experience
var techStacksApp = response.LatestTechStacks.FirstOrDefault(x => x.Id == TechStacksAppId);
if (techStacksApp != null)
{
response.LatestTechStacks.RemoveAll(x => x.Id == TechStacksAppId);
response.LatestTechStacks.Insert(0, techStacksApp);
}
return(response);
}
