code stringlengths 1 2.01M | repo_name stringlengths 3 62 | path stringlengths 1 267 | language stringclasses 231 values | license stringclasses 13 values | size int64 1 2.01M |
|---|---|---|---|---|---|
using Samba.Domain.Models.Menus;
using Samba.Domain.Models.Tickets;
using Samba.Localization.Properties;
using Samba.Persistance.Data;
using Samba.Presentation.Common.ModelBase;
namespace Samba.Modules.MenuModule
{
public class ScreenMenuListViewModel : EntityCollectionViewModelBase<ScreenMenuViewModel, ScreenMenu>
{
protected override ScreenMenuViewModel CreateNewViewModel(ScreenMenu model)
{
return new ScreenMenuViewModel(model);
}
protected override ScreenMenu CreateNewModel()
{
return new ScreenMenu();
}
protected override string CanDeleteItem(ScreenMenu model)
{
var count = Dao.Count<Department>(x=>x.ScreenMenuId == model.Id);
if (count > 0) return Resources.DeleteErrorMenuViewUsedInDepartment;
return base.CanDeleteItem(model);
}
}
}
| zzgaminginc-pointofssale | Samba.Modules.MenuModule/ScreenMenuListViewModel.cs | C# | gpl3 | 927 |
using Samba.Domain.Models.Inventory;
using Samba.Domain.Models.Menus;
using Samba.Domain.Models.Settings;
using Samba.Localization.Properties;
using Samba.Persistance.Data;
using Samba.Presentation.Common;
using Samba.Presentation.Common.ModelBase;
using Samba.Presentation.Common.Services;
using Samba.Services;
using System.Linq;
namespace Samba.Modules.MenuModule
{
public class MenuItemListViewModel : EntityCollectionViewModelBase<MenuItemViewModel, MenuItem>
{
public MenuItemListViewModel()
{
CreateBatchMenuItems = new CaptionCommand<string>(Resources.BatchCreteProducts, OnCreateBatchMenuItems);
CustomCommands.Add(CreateBatchMenuItems);
}
public ICaptionCommand CreateBatchMenuItems { get; set; }
private void OnCreateBatchMenuItems(string value)
{
var values = InteractionService.UserIntraction.GetStringFromUser(
Resources.BatchCreteProducts,
Resources.BatchCreateProductsDialogHint);
var createdItems = new DataCreationService().BatchCreateMenuItems(values, Workspace);
Workspace.CommitChanges();
foreach (var mi in createdItems)
{
var mv = CreateNewViewModel(mi);
mv.Init(Workspace);
Items.Add(mv);
}
}
protected override System.Collections.Generic.IEnumerable<MenuItem> SelectItems()
{
return Workspace.All<MenuItem>();
}
protected override MenuItemViewModel CreateNewViewModel(MenuItem model)
{
return new MenuItemViewModel(model);
}
protected override MenuItem CreateNewModel()
{
return MenuItem.Create();
}
protected override string CanDeleteItem(MenuItem model)
{
var count = Dao.Count<ScreenMenuItem>(x => x.MenuItemId == model.Id);
if (count > 0) return Resources.DeleteErrorProductUsedInMenu;
if (count == 0) count = Dao.Count<Recipe>(x => x.Portion.MenuItemId == model.Id);
if (count > 0) return Resources.DeleteErrorProductUsedInReceipt;
count = Dao.Count<MenuItemProperty>(x => x.MenuItemId == model.Id);
if (count > 0) return Resources.DeleteErrorProductUsedInMenuItemProperty;
count = Dao.Count<PrinterMap>(x => x.MenuItem.Id == model.Id);
if (count > 0) return Resources.DeleteErrorProductUsedInPrinterMap;
return base.CanDeleteItem(model);
}
}
}
| zzgaminginc-pointofssale | Samba.Modules.MenuModule/MenuItemListViewModel.cs | C# | gpl3 | 2,640 |
using System.Windows.Controls;
namespace Samba.Modules.MenuModule
{
/// <summary>
/// Interaction logic for MenuItemPropertyGroupView.xaml
/// </summary>
public partial class MenuItemPropertyGroupView : UserControl
{
public MenuItemPropertyGroupView()
{
InitializeComponent();
}
private void DataGrid_CellEditEnding(object sender, DataGridCellEditEndingEventArgs e)
{
if (e.EditingElement is TextBox)
{
((TextBox)e.EditingElement).Text = ((TextBox)e.EditingElement).Text.Replace("\b", "");
}
}
}
}
| zzgaminginc-pointofssale | Samba.Modules.MenuModule/MenuItemPropertyGroupView.xaml.cs | C# | gpl3 | 662 |
using Samba.Domain.Models.Menus;
using Samba.Presentation.Common;
namespace Samba.Modules.MenuModule
{
public class PortionViewModel : ObservableObject
{
public PortionViewModel(MenuItemPortion model)
{
Model = model;
}
public string Name { get { return Model.Name; } set { Model.Name = value; } }
public decimal Price { get { return Model.Price.Amount; } set { Model.Price.Amount = value; } }
public int Multiplier { get { return Model.Multiplier; } set { Model.Multiplier = value; } }
public string CurrencyCode { get { return Model.Price.CurrencyCode; } set { Model.Price.CurrencyCode = value; } }
public MenuItemPortion Model { get; private set; }
}
}
| zzgaminginc-pointofssale | Samba.Modules.MenuModule/PortionViewModel.cs | C# | gpl3 | 768 |
using System;
using System.Collections.Generic;
using System.Linq;
using Samba.Domain.Models.Menus;
using Samba.Presentation.Common;
namespace Samba.Modules.MenuModule
{
public class PriceViewModel : ObservableObject
{
public MenuItemPortion Model { get; set; }
public string ItemName { get; set; }
public string PortionName { get { return Model.Name; } }
public decimal Price
{
get { return Model.Price.Amount; }
set
{
if (value != Model.Price.Amount)
{
Model.Price.Amount = value;
IsChanged = true;
}
RaisePropertyChanged("Price");
}
}
private readonly IList<MenuItemPriceViewModel> _additionalPrices;
public IList<MenuItemPriceViewModel> AdditionalPrices
{
get { return _additionalPrices; }
}
public decimal this[int index]
{
get { return AdditionalPrices[index].Price; }
set
{
AdditionalPrices[index].Price = value;
IsChanged = true;
}
}
private bool _isChanged;
public bool IsChanged
{
get { return _isChanged; }
set
{
_isChanged = value;
RaisePropertyChanged("IsChanged");
}
}
public PriceViewModel(MenuItemPortion model, string itemName, IEnumerable<string> tags)
{
Model = model;
ItemName = itemName;
_additionalPrices = new List<MenuItemPriceViewModel>();
tags.ToList().ForEach(x =>
{
var pr = model.Prices.SingleOrDefault(y => y.PriceTag == x);
if (pr != null) _additionalPrices.Add(new MenuItemPriceViewModel(pr));
});
}
public void AddPrice(string tag)
{
var pr = new MenuItemPrice { PriceTag = tag };
Model.Prices.Add(pr);
AdditionalPrices.Add(new MenuItemPriceViewModel(pr));
}
}
}
| zzgaminginc-pointofssale | Samba.Modules.MenuModule/PriceViewModel.cs | C# | gpl3 | 2,345 |
using System.Windows.Controls;
namespace Samba.Modules.MenuModule
{
/// <summary>
/// Interaction logic for TicketTagGroupView.xaml
/// </summary>
public partial class TicketTagGroupView : UserControl
{
public TicketTagGroupView()
{
InitializeComponent();
}
private void DataGrid_CellEditEnding(object sender, DataGridCellEditEndingEventArgs e)
{
if (e.EditingElement is TextBox)
{
((TextBox)e.EditingElement).Text = ((TextBox)e.EditingElement).Text.Replace("\b", "");
}
}
}
}
| zzgaminginc-pointofssale | Samba.Modules.MenuModule/TicketTagGroupView.xaml.cs | C# | gpl3 | 641 |
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using Samba.Domain.Models.Menus;
using Samba.Infrastructure;
using Samba.Infrastructure.Data;
using Samba.Localization.Properties;
using Samba.Presentation.Common;
using Samba.Presentation.Common.ModelBase;
namespace Samba.Modules.MenuModule
{
public class MenuItemPropertyGroupViewModel : EntityViewModelBase<MenuItemPropertyGroup>
{
private IWorkspace _workspace;
private readonly ObservableCollection<MenuItemPropertyViewModel> _properties;
public ObservableCollection<MenuItemPropertyViewModel> Properties { get { return _properties; } }
public MenuItemPropertyViewModel SelectedProperty { get; set; }
public ICaptionCommand AddPropertyCommand { get; set; }
public ICaptionCommand DeletePropertyCommand { get; set; }
public bool SingleSelection { get { return Model.SingleSelection; } set { Model.SingleSelection = value; } }
public bool MultipleSelection { get { return Model.MultipleSelection; } set { Model.MultipleSelection = value; } }
public bool ForceValue { get { return Model.ForceValue; } set { Model.ForceValue = value; } }
public bool CalculateWithParentPrice { get { return Model.CalculateWithParentPrice; } set { Model.CalculateWithParentPrice = value; } }
public int ButtonHeight { get { return Model.ButtonHeight; } set { Model.ButtonHeight = value; } }
public int ColumnCount { get { return Model.ColumnCount; } set { Model.ColumnCount = value; } }
public int TerminalButtonHeight { get { return Model.TerminalButtonHeight; } set { Model.TerminalButtonHeight = value; } }
public int TerminalColumnCount { get { return Model.TerminalColumnCount; } set { Model.TerminalColumnCount = value; } }
public string GroupTag { get { return Model.GroupTag; } set { Model.GroupTag = value; } }
public MenuItemPropertyGroupViewModel(MenuItemPropertyGroup model)
: base(model)
{
_properties = new ObservableCollection<MenuItemPropertyViewModel>(GetProperties(model));
AddPropertyCommand = new CaptionCommand<string>(string.Format(Resources.Add_f, Resources.Modifier), OnAddPropertyExecuted);
DeletePropertyCommand = new CaptionCommand<string>(string.Format(Resources.Delete_f, Resources.Modifier), OnDeletePropertyExecuted, CanDeleteProperty);
}
private void OnDeletePropertyExecuted(string obj)
{
if (SelectedProperty == null) return;
if (SelectedProperty.Model.Id > 0)
_workspace.Delete(SelectedProperty.Model);
Model.Properties.Remove(SelectedProperty.Model);
Properties.Remove(SelectedProperty);
}
private bool CanDeleteProperty(string arg)
{
return SelectedProperty != null;
}
private void OnAddPropertyExecuted(string obj)
{
Properties.Add(new MenuItemPropertyViewModel(MenuItem.AddDefaultMenuItemProperty(Model)));
}
private static IEnumerable<MenuItemPropertyViewModel> GetProperties(MenuItemPropertyGroup baseModel)
{
return baseModel.Properties.Select(item => new MenuItemPropertyViewModel(item));
}
public override string GetModelTypeString()
{
return Resources.ModifierGroup;
}
protected override void Initialize(IWorkspace workspace)
{
_workspace = workspace;
}
public override Type GetViewType()
{
return typeof(MenuItemPropertyGroupView);
}
}
}
| zzgaminginc-pointofssale | Samba.Modules.MenuModule/MenuItemPropertyGroupViewModel.cs | C# | gpl3 | 3,777 |
using System.Windows.Controls;
namespace Samba.Modules.MenuModule
{
/// <summary>
/// Interaction logic for TaxServiceView.xaml
/// </summary>
public partial class TaxServiceTemplateView : UserControl
{
public TaxServiceTemplateView()
{
InitializeComponent();
}
}
}
| zzgaminginc-pointofssale | Samba.Modules.MenuModule/TaxServiceTemplateView.xaml.cs | C# | gpl3 | 345 |
using System.Windows.Controls;
namespace Samba.Modules.MenuModule
{
/// <summary>
/// Interaction logic for VatTemplateView.xaml
/// </summary>
public partial class VatTemplateView : UserControl
{
public VatTemplateView()
{
InitializeComponent();
}
}
}
| zzgaminginc-pointofssale | Samba.Modules.MenuModule/VatTemplateView.xaml.cs | C# | gpl3 | 332 |
using System;
using System.Collections.Generic;
using System.ComponentModel;
using Samba.Domain.Models.Menus;
using Samba.Localization.Properties;
using Samba.Persistance.Data;
using Samba.Presentation.Common;
namespace Samba.Modules.MenuModule
{
public class MenuItemPropertyViewModel : ObservableObject
{
public MenuItemProperty Model { get; set; }
public MenuItemPropertyViewModel(MenuItemProperty model)
{
Model = model;
if (string.IsNullOrEmpty(model.Name))
model.Name = string.Format("[{0}]", Resources.NewProperty);
UpdateMenuItem(model.MenuItemId);
}
public string Name { get { return Model.Name; } set { Model.Name = value; } }
public decimal Price
{
get { return Model.Price.Amount; }
set { Model.Price.Amount = value; }
}
public string CurrencyCode { get { return Model.Price.CurrencyCode; } set { Model.Price.CurrencyCode = value; } }
public int MenuItemId
{
get { return Model.MenuItemId; }
set
{
Model.MenuItemId = value;
UpdateMenuItem(value);
}
}
private MenuItem _menuItem;
public MenuItem MenuItem
{
get
{
return _menuItem;
}
set
{
_menuItem = value;
MenuItemId = value.Id;
}
}
private IEnumerable<MenuItem> _menuItems;
public IEnumerable<MenuItem> MenuItems
{
get { return _menuItems ?? (_menuItems = Dao.Query<MenuItem>()); }
}
private void UpdateMenuItem(int value)
{
if (value > 0)
{
if (MenuItem == null || MenuItem.Id != value)
MenuItem = Dao.Single<MenuItem>(x => x.Id == value, x => x.PropertyGroups, x => x.Portions);
}
}
}
}
| zzgaminginc-pointofssale | Samba.Modules.MenuModule/MenuItemPropertyViewModel.cs | C# | gpl3 | 2,089 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-02-15.
# $Id$
#
from __future__ import with_statement
import hashlib
import logging
import os
import sys
from optparse import OptionParser
from PIL import Image
_MAGINK_VERSION = "magink version 1.0, by ZHENG Zhong"
_MAGINK_ID = "MAGINK1"
def _read_binary_file(file_name):
"""
Reads a binary file and returns a byte array as a str.
"""
with open(file_name, "rb") as file:
bytes = file.read()
return bytes
def _save_binary_file(file_name, bytes):
"""
Writes a byte array as a str to a binary file.
"""
with open(file_name, "wb") as file:
file.write(bytes)
file.flush()
def _prepend_header(bytes):
"""
Prepends header string to the bytes.
"""
md5 = hashlib.md5(bytes).hexdigest().upper()
header = "%s/%s/%d/" % (_MAGINK_ID, md5, len(bytes))
logging.info("Prepending header: %s" % header)
return header + bytes
def _check_header(bytes):
"""
Extracts header string from the input bytes, and checks the header.
"""
try:
magink_id, md5, length, bytes = bytes.split("/", 3)
if magink_id != _MAGINK_ID:
raise Exception("inconsistent Magink ID: %s" % magink_id)
elif not length.isdigit():
raise Exception("bad length format: %s" % length)
bytes = bytes[:int(length)]
if md5 != hashlib.md5(bytes).hexdigest().upper():
raise Exception("inconsistent MD5: %s" % md5)
logging.info("Extracting: %s/%s/%s/..." % (magink_id, md5, length))
return bytes
except Exception, exc:
logging.error("Failed to check header in bytes: %s" % exc)
return None
def _get_color_mapping(channels):
channels = filter(lambda c: c in "RGB", channels.upper())
mapping = []
for c in channels:
mapping.append("RGB".index(c))
return mapping or [0, 1, 2]
def _encrypt_rgb(bytes, mask_file_name, channels):
"""
Encrypts bytes into color channels of the mask image file.
"""
# Convert the channels string to color mapping.
color_mapping = _get_color_mapping(channels)
# Check the size of the mask image file.
mask_image = Image.open(mask_file_name)
width, height = mask_image.size
if width * height * len(color_mapping) < len(bytes):
raise Exception("Mask image is too small for %d bytes." % len(bytes))
logging.info("Encrypting %d bytes to mask image %s..." % (len(bytes), mask_file_name))
# Create the target image.
target_image = Image.new("RGB", (width, height))
# Encrypt the data into the specified channels.
mask_pixels = mask_image.load()
target_pixels = target_image.load()
for y in range(0, height):
for x in range(0, width):
rgb = list(mask_pixels[x, y])
for i in range(0, len(color_mapping)):
pos = y * width * len(color_mapping) + x * len(color_mapping) + i
if pos < len(bytes):
rgb[color_mapping[i]] ^= ord(bytes[pos])
target_pixels[x, y] = tuple(rgb)
# Return the encrypted image.
return target_image
def _decrypt_rgb(image, mask_file_name, channels):
"""
Decrypts bytes from color channels of the image file.
"""
# Convert the channels string to color mapping.
color_mapping = _get_color_mapping(channels)
# Check the size of the mask image file.
mask_image = Image.open(mask_file_name)
if image.size != mask_image.size:
raise Exception("Size of mask image is inconsistent, should be %dx%d." % image.size)
bytes = []
width, height = image.size
mask_pixels = mask_image.load()
pixels = image.load()
for y in range(0, height):
for x in range(0, width):
mask_rgb = mask_pixels[x, y]
rgb = pixels[x, y]
for index in color_mapping:
byte_ord = mask_rgb[index] ^ rgb[index]
bytes.append(chr(byte_ord))
logging.info("Decrypting the %dx%d image to %d bytes..." % (width, height, len(bytes)))
return "".join(bytes)
def _create_option_parser():
"""
Creates an option parser to parse command-line arguments.
"""
parser = OptionParser(usage="""%prog <INPUT_FILE_NAME>
Use -h or --help for help.""")
parser.add_option(
"-v", "--version",
dest="version",
default=False,
action="store_true",
help="print magink version and exit"
)
parser.add_option(
"-m", "--mask",
dest="mask",
metavar="MASK_FILE",
help="specify the mask image file"
)
parser.add_option(
"-c", "--channels",
dest="channels",
default="RGB",
metavar="RGB",
help="specify the encryption channels, defaults to RGB"
)
parser.add_option(
"-d", "--decrypt",
dest="decrypt",
default=False,
action="store_true",
help="specify whether to decrypt the file, defaults to encrypt"
)
parser.add_option(
"-o", "--output",
dest="output",
metavar="OUTPUT_FILE",
help="specify the output file (required)"
)
return parser
def main(argv=None):
"""
Main entry point.
"""
# Get command line arguments as necessary.
if argv is None:
argv = sys.argv[1:]
# Configure logging, set logging level to INFO.
logging.basicConfig(format="%(message)s")
logging.getLogger().setLevel(logging.DEBUG)
# Parse command-line arguments to opts and args.
parser = _create_option_parser()
(opts, args) = parser.parse_args(argv)
# If the version info is requested, print version info and exit.
if opts.version:
logging.info(_MAGINK_VERSION)
exit()
# Check opts and args.
if not opts.mask:
parser.error("The mask image file (-m or --mask) is required.")
elif not opts.output:
parser.error("The output file name (-o or --output) is required.")
elif not args:
parser.error("The input file name argument is required.")
elif len(args) > 1:
parser.error("Too many input file name arguments.")
input_file_name = args[0]
output_file_name = opts.output
mask_file_name = opts.mask
channels = opts.channels
if opts.decrypt:
try:
if not input_file_name.lower().endswith(".png"):
raise Exception("The file to decrypt should be a PNG file.")
image = Image.open(input_file_name)
bytes = _decrypt_rgb(image, mask_file_name, channels)
bytes = _check_header(bytes)
_save_binary_file(output_file_name, bytes)
logging.info("Decrypted %s -> %s" % (input_file_name, output_file_name))
except Exception, exc:
logging.error("Failed to decrypt file: %s" % exc)
else:
try:
bytes = _read_binary_file(input_file_name)
bytes = _prepend_header(bytes)
image = _encrypt_rgb(bytes, mask_file_name, channels)
if not output_file_name.lower().endswith(".png"):
output_file_name += ".png"
image.save(output_file_name, "PNG")
logging.info("Encrypted %s -> %s" % (input_file_name, output_file_name))
except Exception, exc:
logging.error("Failed to encrypt file: %s" % exc)
if __name__ == "__main__":
main()
# EOF
| zzheng | zhengzhong/scripts/magink.py | Python | asf20 | 7,770 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-02-15.
# $Id$
#
from __future__ import with_statement
import logging
import os
import sys
from xml.dom import minidom
_IGNORE = (
"&#", "•", "©", " ", "»", "«",
'<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">',
)
def check_template(template_file):
logging.info("Checking: %s ..." % template_file)
good = False
error = None
with open(template_file) as f:
try:
content = f.read()
for ignore in _IGNORE:
content = content.replace(ignore, "[ignored]")
xml_str = "<root>" + content + "</root>"
try:
xdoc = minidom.parseString(xml_str)
good = True
error = None
except Exception, exc:
logging.error("Invalid XHTML found in %s: %s" % (template_file, exc))
good = False
error = str(exc)
except Exception, exc:
logging.error("Error checking %s: %s" % (template_file, exc))
good = False
error = str(exc)
finally:
f.close()
return (good, error)
def check_templates(template_dir):
checked = 0
ignored = 0
bad_templates = []
for dir_path, dir_names, file_names in os.walk(template_dir):
for file_name in file_names:
template_file = os.path.join(dir_path, file_name)
if template_file.lower().endswith(".html"):
good, error = check_template(template_file)
if not good:
bad_templates.append((template_file, error))
checked += 1
else:
ignored += 1
failed = len(bad_templates)
logging.info("%d bad templates found in %d files (%d ignored)." % (failed, checked, ignored))
if bad_templates:
for template_file, error in bad_templates:
logging.error(template_file)
logging.error(" --> " + error)
def main(argv=None):
"""
Main entry point.
"""
# Get template top directory.
argv = argv or sys.argv[1:]
if len(argv) == 1:
template_dir = argv[0]
else:
template_dir = os.getcwd()
# Configure logging, set logging level to INFO.
logging.basicConfig(format="%(message)s")
logging.getLogger().setLevel(logging.DEBUG)
# Check templates.
check_templates(template_dir)
if __name__ == "__main__":
main()
# EOF
| zzheng | zhengzhong/scripts/xtemplate.py | Python | asf20 | 2,729 |
/**
Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
Created on 2010-05-27.
$Id$
*/
/*--------------------------------------------------------------------------------------------------
* HTML elements
*------------------------------------------------------------------------------------------------*/
body {
margin: 0;
padding: 0;
text-align: center;
font: normal normal 14px Arial,Helvetica,sans-serif;
line-height: 1.4em;
}
a, a:link, a:visited {
text-decoration: none;
color: #2090D0;
}
a:hover {
text-decoration: underline;
color: #2090D0;
}
a img {
border-width: 0;
}
h1, h2, h3 {
margin: 0;
padding: 8px 0 8px 0;
}
h1 {
color: #888888;
font-weight: bold;
font-size: 200%;
}
h2 {
font-weight: normal;
font-size: 120%;
color: #666666;
}
h3 {
font-weight: normal;
font-size: 110%;
}
h5 {
margin: 0;
padding: 4px;
font-weight: normal;
font-size: 110%;
color: #666666;
text-align: right;
border-top: solid 1px #DDDDDD;
}
p {
margin: 0;
padding: 4px 0 4px 0;
}
ul, ol {
margin: 0;
padding: 4px 0 4px 20px;
}
tt, code, pre, .code {
font-family: 'Courier New',courier,arial, sans-serif;
}
pre {
margin: 4px 0 4px 0;
padding: 4px;
border: solid 1px #888888;
}
/*--------------------------------------------------------------------------------------------------
* outer-wrapper
*------------------------------------------------------------------------------------------------*/
#outer-wrapper {
margin: 0 auto;
padding: 0;
text-align: left;
width: 990px;
min-width: 990px;
border: 1px solid #DDDDDD;
}
/*--------------------------------------------------------------------------------------------------
* topbar-wrapper and footer-wrapper
*------------------------------------------------------------------------------------------------*/
#topbar-wrapper, #footer-wrapper {
margin: 0;
padding: 10px;
font-size: 85%;
line-height: 1.4em;
color: #888888;
}
#topbar-wrapper .topbar-left, #footer-wrapper .footer-left {
float: left;
white-space: nowrap;
}
#topbar-wrapper .topbar-right, #footer-wrapper .footer-right {
float: right;
text-align: right;
white-space: nowrap;
}
#footer-wrapper {
border-top: 1px solid #DDDDDD;
}
#footer-wrapper a {
color: #888888;
}
/*--------------------------------------------------------------------------------------------------
* main-wrapper, sidebar-wrapper and content-wrapper
*------------------------------------------------------------------------------------------------*/
#main-wrapper {
margin: 0;
padding: 10px;
}
#sidebar-wrapper {
margin: 0;
padding: 0;
display: inline;
float: right;
width: 30%;
overflow: hidden;
}
#sidebar-wrapper h2 {
font: normal bold 120% "Century Gothic",Arial,Helvetica,sans-serif;
margin: 0;
padding: 4px 0 10px 0;
text-transform: uppercase;
color: #2090D0;
}
#sidebar-wrapper ul {
margin: 0;
padding: 0;
}
#sidebar-wrapper ul li {
margin: 0;
padding: 4px;
color: #666666;
font-size: 90%;
list-style: none outside none;
border-top: 1px solid #DDDDDD;
text-indent: 0;
}
#sidebar-wrapper ul li a {
color: #666666;
}
#sidebar-wrapper ul li a:hover {
text-decoration: none;
color: #2090D0;
}
#sidebar-wrapper dl {
margin: 0;
padding: 4px 0 4px 0;
}
#sidebar-wrapper dt {
margin: 0;
padding: 0 0 2px 0;
font-weight: bold;
}
#sidebar-wrapper dd {
margin: 0;
padding: 0 0 0 20px;
}
#content-wrapper {
margin: 0;
padding: 0;
display: inline;
float: left;
width: 68%;
}
| zzheng | zhengzhong/website/static/css/layout.css | CSS | asf20 | 3,773 |
/**
Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
Created on 2008-12-03.
$Id$
*/
.table {
margin: 0;
padding: 4px 0 4px 0;
width: 100%;
}
.table th, .table td {
margin: 0;
padding: 4px;
text-align: left;
line-height: 1.2em;
}
.table thead th {
color: #666666;
font-weight: normal;
border-bottom: 1px solid #BBBBBB;
}
.zebra tbody tr.odd {
background-color: #FFFFFF;
}
.zebra tbody tr.even {
background-color: #E8E8E8;
}
.zebra tbody tr.odd:hover, .zebra tbody tr.even:hover {
background-color: #FFFFDD;
}
.table-info {
margin: 0;
padding: 4px 8px 4px 8px;
text-align: right;
color: #666666;
}
| zzheng | zhengzhong/website/static/css/table.css | CSS | asf20 | 705 |
/**
Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
Created on 2010-05-27.
$Id$
*/
.ui-widget {
font: normal normal 100% Arial,Helvetica,sans-serif;
}
| zzheng | zhengzhong/website/static/css/jquery_ui.css | CSS | asf20 | 181 |
/**
Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
Created on 2010-05-27.
$Id$
*/
/*--------------------------------------------------------------------------------------------------
* Common CSS classes
*------------------------------------------------------------------------------------------------*/
.clear {
clear: both;
}
.nowrap {
white-space: nowrap;
}
.section {
margin: 0;
padding: 0 0 10px 0;
}
.photo {
margin: 4px 0 4px 0;
padding: 4px;
border: 1px solid #BBBBBB;
}
.photo:hover {
border: 1px solid #888888;
}
a.image {
text-decoration: none;
}
img.icon {
vertical-align: text-bottom;
}
/*--------------------------------------------------------------------------------------------------
* Prompt
*------------------------------------------------------------------------------------------------*/
.info-prompt, .error-prompt {
margin: 10px 0 10px 0;
padding: 10px;
border-radius: 4px;
-moz-border-radius: 4px;
-webkit-border-radius: 4px;
}
.info-prompt {
background-color: #E8EEFA;
border: 1px solid #C3D9FF;
}
.error-prompt {
background-color: #FAFDCE;
border: 1px solid #FACC00;
}
| zzheng | zhengzhong/website/static/css/common.css | CSS | asf20 | 1,229 |
/**
Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
Created on 2010-05-27.
$Id$
*/
/*--------------------------------------------------------------------------------------------------
* common styles applied to all kinds of forms
*------------------------------------------------------------------------------------------------*/
.required input, .required textarea, .required select {
background-color: #FFFFDD;
}
.disabled-value {
color: #666666;
background-color: #DDDDDD;
}
.label, .input, .radio, .checkbox, .error-list, .help-text {
margin: 0;
padding: 4px 0 4px 0;
}
.error-list {
color: #FF0000;
font-size: 90%;
}
.error-list ul {
margin: 0;
padding: 0;
}
.error-list li {
margin: 0;
padding: 0;
text-indent: 0;
list-style: none outside none;
}
.help-text {
color: #888888;
font-size: 90%;
}
.input textarea,
.input input,
.input select,
.disabled-value {
margin: 0;
padding: 4px;
font-size: 100%;
border: 1px solid #BBBBBB;
border-radius: 4px;
-moz-border-radius: 4px;
-webkit-border-radius: 4px;
}
.input textarea {
font-family: 'Courier New',courier,arial, sans-serif;
}
.input select option {
font-size: 100%;
font-family: Arial,Helvetica,sans-serif;
}
.radio input, .checkbox input {
padding: 0 0 0 10px;
}
.radio ul {
margin: 0;
padding: 0;
}
.radio li {
margin: 0;
padding: 0;
text-indent: 0;
list-style: none outside none;
}
input.button, a.button {
padding: 2px 4px 2px 4px;
font-weight: bold;
font-size: 100%;
text-decoration: none;
background-color: #2090D0;
color: #FFFFFF;
border: none;
border-radius: 4px;
-moz-border-radius: 4px;
-webkit-border-radius: 4px;
}
input.button:hover, a.button:hover {
text-decoration: none;
background-color: #2060B0;
color: #FFFFFF;
border: none;
}
/*--------------------------------------------------------------------------------------------------
* small-sized (S) form
*------------------------------------------------------------------------------------------------*/
.form {
margin: 0;
padding: 4px 0 4px 0;
}
.form .input textarea,
.form .input input,
.form .input select,
.form .disabled-value {
width: 200px;
}
| zzheng | zhengzhong/website/static/css/form.css | CSS | asf20 | 2,343 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-02-05.
# $Id$
#
#
# Set DJANGO_SETTINGS_MODULE variable.
#
import os
os.environ["DJANGO_SETTINGS_MODULE"] = "zheng.settings"
#
# Select Django version.
#
from google.appengine.dist import use_library
use_library("django", "1.1")
#
# Force Django to reload its settings.
#
from django.conf import settings
settings._target = None
#
# Update Django signal handlers (for Django version 1.1).
#
import logging
import django.db
from django.core.signals import got_request_exception
def log_exception(*args, **kwds):
logging.exception("Exception in request:")
got_request_exception.disconnect(django.db._rollback_on_exception)
got_request_exception.connect(log_exception)
#---------------------------------------------------------------------------------------------------
from django.core.handlers.wsgi import WSGIHandler
from google.appengine.ext.webapp.util import run_wsgi_app
def main():
application = WSGIHandler()
run_wsgi_app(application)
if __name__ == "__main__":
main()
# EOF
| zzheng | zhengzhong/website/main.py | Python | asf20 | 1,203 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2008 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2008-12-19.
# $Id$
#
from django.conf.urls.defaults import *
from zheng.apps.homepage.views import *
urlpatterns = patterns("",
url(
r"^$",
home,
name="zheng.home"
),
url(
r"^java/$",
about_java,
name="zheng.about_java"
),
url(
r"^.*/$",
not_found,
name="zheng.not_found"
),
)
# EOF
| zzheng | zhengzhong/website/zheng/apps/homepage/urls.py | Python | asf20 | 541 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2008 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-02-05.
# $Id$
#
| zzheng | zhengzhong/website/zheng/apps/homepage/__init__.py | Python | asf20 | 150 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2008 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2008-12-19.
# $Id$
#
from django.http import HttpRequest, HttpResponse, HttpResponseRedirect
from django.template import RequestContext
from django.shortcuts import render_to_response
def home(request):
return render_to_response("homepage/home.html", {}, RequestContext(request))
def about_java(request):
return render_to_response("homepage/about_java.html", {}, RequestContext(request))
def not_found(request):
data = {"bad_url": request.path,}
response = render_to_response("homepage/not_found.html", data, RequestContext(request))
response.status_code = 404 # not found.
return response
# EOF
| zzheng | zhengzhong/website/zheng/apps/homepage/views.py | Python | asf20 | 784 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2008 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-04-21.
# $Id$
#
| zzheng | zhengzhong/website/zheng/apps/__init__.py | Python | asf20 | 150 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-02-05.
# $Id$
#
import os
DEBUG = True
TEMPLATE_DEBUG = DEBUG
ADMINS = (
("ZHENG Zhong", "@".join(["heavyzheng", "gmail.com"])),
)
MANAGERS = ADMINS
# Database configurations.
# @appengine: Django models are not supported: set all DATABASE_* to empty.
DATABASE_ENGINE = ""
DATABASE_NAME = ""
DATABASE_USER = ""
DATABASE_PASSWORD = ""
DATABASE_HOST = ""
DATABASE_PORT = ""
# Local time zone for this installation. Choices can be found here:
# http://en.wikipedia.org/wiki/List_of_tz_zones_by_name
# although not all choices may be available on all operating systems.
# If running in a Windows environment this must be set to the same as your
# system time zone.
TIME_ZONE = "UTC"
# Language code for this installation. All choices can be found here:
# http://www.w3.org/TR/REC-html40/struct/dirlang.html#langcodes
# http://blogs.law.harvard.edu/tech/stories/storyReader$15
LANGUAGE_CODE = "en-us"
SITE_ID = 1
# If you set this to False, Django will make some optimizations so as not
# to load the internationalization machinery.
USE_I18N = True
# Absolute path to the directory that holds media.
# Example: "/home/media/media.lawrence.com/"
MEDIA_ROOT = ""
# URL that handles the media served from MEDIA_ROOT.
# Example: "http://media.lawrence.com"
MEDIA_URL = ""
# URL prefix for admin media -- CSS, JavaScript and images. Make sure to use a
# trailing slash.
# Examples: "http://foo.com/media/", "/media/".
ADMIN_MEDIA_PREFIX = "/media/"
# Make this unique, and don't share it with anybody.
SECRET_KEY = "*c(^-34)gdt8=g%3##=*apdl$!w8q-$4bc96+25!%2@%6-pj*x"
# List of callables that automatically populates the context with a few variables.
TEMPLATE_CONTEXT_PROCESSORS = (
"zheng.common.context_processors.common_data_processor",
"zheng.common.context_processors.current_user_processor",
"zheng.common.context_processors.powered_by_processor",
)
# List of callables that know how to import templates from various sources.
TEMPLATE_LOADERS = (
"django.template.loaders.filesystem.load_template_source",
"django.template.loaders.app_directories.load_template_source",
#"django.template.loaders.eggs.load_template_source",
)
TEMPLATE_DIRS = (os.path.normpath(os.path.join(os.path.dirname(__file__), "templates")),)
TEMPLATE_STRING_IF_INVALID = "#TEMPLATE_ERROR#"
MIDDLEWARE_CLASSES = (
"django.middleware.common.CommonMiddleware",
#"django.contrib.sessions.middleware.SessionMiddleware", # @appengine: comment this line!
#"django.middleware.locale.LocaleMiddleware",
#"django.contrib.auth.middleware.AuthenticationMiddleware",
"django.middleware.doc.XViewMiddleware",
"zheng.common.middlewares.RenderErrorMiddleware",
)
ROOT_URLCONF = "zheng.urls"
# For serving static files.
STATIC_DOC_ROOT = os.path.normpath(os.path.join(os.path.dirname(__file__), "..", "static"))
INSTALLED_APPS = (
#"django.contrib.admin",
#"django.contrib.auth",
#"django.contrib.contenttypes",
#"django.contrib.sessions",
#"django.contrib.sites",
#"django.contrib.webdesign",
"zheng", # for loading templates
"zheng.apps.homepage",
)
#---------------------------------------------------------------------------------------------------
# All the MY_* settings are website-specific.
MY_STATIC_URL_PREFIX = "/static"
MY_ROOT_DIR = os.path.normpath(os.path.join(os.path.dirname(__file__), ".."))
MY_EMAIL_DOMAIN = "gmail.com"
MY_WEBMASTER_EMAILS = (
"@".join(["heavyzheng", MY_EMAIL_DOMAIN]),
)
# EOF
| zzheng | zhengzhong/website/zheng/settings.py | Python | asf20 | 3,746 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2008 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2008-04-28.
# $Id$
#
from django.conf.urls.defaults import *
urlpatterns = patterns("",
(r"^", include("zheng.apps.homepage.urls")),
)
# EOF
| zzheng | zhengzhong/website/zheng/urls.py | Python | asf20 | 292 |
{% extends "base.html" %}
{% comment %}
<!--
Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
Created on 2010-05-19.
$Id$
-->
{% endcomment %}
{#________________________________________________________________________________________________#}
{% block html_title %} Error {% endblock %}
{#________________________________________________________________________________________________#}
{% block main %}
<div class="section">
<h1>Oops! An error occurred...</h1>
</div>
<div class="section">
<div class="error-prompt">
{{ error|escape }}.
<a href="{% url zheng.home %}">Return home »</a>
</div>
</div>
{% endblock %}
| zzheng | zhengzhong/website/zheng/templates/error.html | HTML | asf20 | 711 |
{% extends "base.html" %}
{% comment %}
<!--
Copyright (C) 2008 ZHENG Zhong <http://www.zhengzhong.net/>
Created on 2008-12-19.
$Id$
-->
{% endcomment %}
{#________________________________________________________________________________________________#}
{% block html_title %} About Me {% endblock %}
{#________________________________________________________________________________________________#}
{% block content %}
<div class="section">
<h1>Hi.</h1>
</div>
<div class="section">
<p>
My name is ZHENG Zhong ( 郑重 in Chinese ), and I am a programmer from Nanjing, China.
I am currently living in Paris with my dog <a href="{% url zheng.about_java %}">Java</a>.
If you want to know more about me, you may visit
<a href="http://blog.zhengzhong.net/">my blog</a> and
<a href="http://www.flickr.com/photos/zhengzhong/">my Flickr photostream</a>.
You may get in touch with me via <heavyzheng nospam-at gmail D0T com>.
</p>
</div>
<div class="section" style="text-align: center;">
<a class="image" href="http://www.flickr.com/photos/zhengzhong/3119407786/">
<img class="photo" src="http://farm4.static.flickr.com/3203/3119407786_ef301503fb.jpg" alt="ZHENG Zhong"/>
</a>
<br/>
Sept. 8, 2003 - Maison des Mines et des Ponts et Chaussées, Paris
</div>
{% endblock %}
| zzheng | zhengzhong/website/zheng/templates/homepage/home.html | HTML | asf20 | 1,417 |
{% extends "base.html" %}
{% comment %}
<!--
Copyright (C) 2008 ZHENG Zhong <http://www.zhengzhong.net/>
Created on 2008-12-19.
$Id$
-->
{% endcomment %}
{#________________________________________________________________________________________________#}
{% block html_title %} Java {% endblock %}
{#________________________________________________________________________________________________#}
{% block content %}
<div class="section">
<h1>About Java</h1>
</div>
<div class="section">
<p>
Java is a <a href="http://en.wikipedia.org/wiki/Golden_retriever">golden retriever</a>
named after <a href="http://en.wikipedia.org/wiki/Java_%28programming_language%29">one of
my favorite programming language</a>. He was born on July 7 2006, and has been living with
<a href="{% url zheng.home %}">me</a> since October 2 2006. He loves to sleep on my feet,
play with his toys, go out for walks, and chase whatever you throw.
</p>
<p>
I believe Java understands my language, although he never speaks. It's good to have a friend
who is always willing to listen.
</p>
</div>
<div class="section" style="text-align: center;">
<a class="image" href="http://www.flickr.com/photos/zhengzhong/3152173996/">
<img class="photo" src="http://farm4.static.flickr.com/3112/3152173996_210c145da9.jpg" alt="Java"/>
</a>
<br/>
Java - Nov. 24, 2008 - Champigny sur Marne, France
</div>
{% endblock %}
| zzheng | zhengzhong/website/zheng/templates/homepage/about_java.html | HTML | asf20 | 1,538 |
{% extends "base.html" %}
{% comment %}
<!--
Copyright (C) 2008 ZHENG Zhong <http://www.zhengzhong.net/>
Created on 2008-12-19.
$Id$
-->
{% endcomment %}
{#________________________________________________________________________________________________#}
{% block html_title %} Page not found {% endblock %}
{#________________________________________________________________________________________________#}
{% block main %}
<div class="section">
<h1>Oops! Page not found...</h1>
</div>
<div class="section">
<div class="error-prompt">
The URL <b>{{ bad_url|escape }}</b> you requested cannot be found.
<a href="{% url zheng.home %}">Return home »</a>
</div>
</div>
{% endblock %}
| zzheng | zhengzhong/website/zheng/templates/homepage/not_found.html | HTML | asf20 | 764 |
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
{% comment %}
<!--
Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
Created on 2010-02-08.
$Id$
-->
{% endcomment %}
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
<meta name="description" content="ZHENG Zhong's personal website"/>
<meta name="keywords" content="ZHENG Zhong,zheng,zzheng,zhengzhong,heavyz,heavyzheng,"/>
<meta content="ZHENG Zhong" name="author"/>
<link rel="shortcut icon" type="image/ico" href="/favicon.ico"/>
<link rel="stylesheet" type="text/css" media="screen,print" href="{{ static_ }}/css/layout.css"/>
<link rel="stylesheet" type="text/css" media="screen,print" href="{{ static_ }}/css/common.css"/>
<link rel="stylesheet" type="text/css" media="screen,print" href="{{ static_ }}/css/form.css"/>
<!-- jQuery and jQuery UI (via Google Javascript API) -->
<script src="http://www.google.com/jsapi?key={{ google_ajax_api_key_ }}" type="text/javascript"></script>
<script type="text/javascript">//<![CDATA[
google.load("jquery", "1.4.2");
google.load("jqueryui", "1.8.0");
//]]></script>
<!-- jQuery UI flick theme (with customization) -->
<link rel="stylesheet" type="text/css" media="screen,print" href="http://ajax.googleapis.com/ajax/libs/jqueryui/1.7.2/themes/flick/jquery-ui.css"/>
<link rel="stylesheet" type="text/css" media="screen,print" href="{{ static_ }}/css/jquery_ui.css"/>
<title>{% block html_title %}{% endblock %} :: ZHENG Zhong</title>
{% block html_head %}{% endblock %}
</head>
<body>
<div id="outer-wrapper">
<!-- topbar-wrapper ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
<div id="topbar-wrapper">
<div class="topbar-left"></div>
<div class="topbar-right">
<a href="{% url zheng.home %}">Home</a>
• <a href="http://blog.zhengzhong.net/">Blog</a>
• <a href="http://www.flickr.com/photos/zhengzhong/">Photos</a>
</div>
<div class="clear"></div>
</div><!--/#topbar-wrapper-->
<!-- main-wrapper ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
<div id="main-wrapper">
{% block main %}
<div id="content-wrapper">
{% block content %}
FIXME: content block is required!
{% endblock %}
</div><!--/#content-wrapper-->
<div id="sidebar-wrapper">
{% block sidebar %}
<div class="section">
<h2>Related Links:</h2>
<ul>
<li><a href="http://www.flickr.com/photos/zhengzhong/">Flickr Photostream</a></li>
<li><a href="http://blog.zhengzhong.net/">Personal Blog</a></li>
<li><a href="http://www.linkedin.com/in/zhengzhong">LinkedIn Profile</a></li>
</ul>
</div>
{% endblock %}
</div><!--/#sidebar-wrapper-->
<div class="clear"></div>
{% endblock %}
</div><!--/#main-wrapper-->
<!-- foot-wrapper ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
<div id="footer-wrapper">
<div class="footer-left">
©{% now "Y" %} ZHENG Zhong, All Rights Reserved<br/>
<a href="{% url zheng.home %}">Home</a>
• <a href="http://blog.zhengzhong.net/">Blog</a>
• <a href="http://www.flickr.com/photos/zhengzhong/">Photos</a>
•
{% if user_ %}
<a href="{{ logout_url_ }}">Logout ({{ user_|escape }})</a>
{% else %}
<a href="{{ login_url_ }}">Login</a>
{% endif %}
</div>
<div class="footer-right">
<a href="http://appengine.google.com/">Google App Engine</a>
• <a href="http://www.python.org/">Python {{ python_version_|escape }}</a>
• <a href="http://www.djangoproject.com/">Django {{ django_version_|escape }}</a>
<br/>
<a href="http://validator.w3.org/check?uri=referer">Valid XHTML</a>
• <a href="http://jigsaw.w3.org/css-validator/check/referer">Valid CSS</a>
</div>
<div class="clear"></div>
</div><!--/#footer-wrapper-->
</div><!--/#outer-wrapper-->
</body>
</html>
| zzheng | zhengzhong/website/zheng/templates/base.html | HTML | asf20 | 4,685 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-02-08.
# $Id$
#
__version__ = "0.1"
def get_version():
"""
Returns the website version number.
"""
return __version__
# EOF
| zzheng | zhengzhong/website/zheng/__init__.py | Python | asf20 | 293 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-02-08.
# $Id$
#
import logging
from django.http import HttpRequest, HttpResponse, Http404
from django.template import RequestContext
from django.shortcuts import render_to_response
class DummyMiddleware(object):
def __init__(self):
"""Most middleware classes won't need an initializer since middleware classes are
essentially placeholders for the process_* methods. If you do need some global state you
may use __init__ to set up. However, keep in mind a couple of caveats:
* Django initializes your middleware without any arguments, so you can't define __init__
as requiring any arguments.
* Unlike the process_* methods which get called once per request, __init__ gets called
only once, when the web server starts up.
"""
pass
def process_request(self, request):
"""This function is called on each request, before Django decides which view to execute.
This function should return either None or an HttpResponse object. If it returns None,
Django will continue processing this request, executing any other middleware and, then,
the appropriate view. If it returns an HttpResponse object, Django won't bother calling
ANY other request, view or exception middleware, or the appropriate view; it'll return that
HttpResponse. Response middleware is always called on every response.
"""
return None
def process_view(self, request, view_func, view_args, view_kwargs):
"""This function is called just before Django calls the view. It should return either None
or an HttpResponse object. If it returns None, Django will continue processing this
request, executing any other process_view() middleware and, then, the appropriate view.
If it returns an HttpResponse object, Django won't bother calling ANY other request, view
or exception middleware, or the appropriate view; it'll return that HttpResponse. Response
middleware is always called on every response.
"""
return None
def process_response(self, request, response):
"""This function should return an HttpResponse object. It could alter the given response,
or it could create and return a brand-new HttpResponse.
"""
return response
def process_exception(self, request, exception):
"""This function is called when a view raises an exception. This function should return
either None or an HttpResponse object. If it returns an HttpResponse object, the response
will be returned to the browser. Otherwise, default exception handling kicks in.
"""
return None
class RenderErrorMiddleware(object):
ERROR_TEMPLATE = "error.html"
def process_exception(self, request, exception):
logging.error("Error occurred: %s - %s" % (type(exception), exception))
if not isinstance(exception, Http404):
logging.exception(exception)
try:
data = {"error": exception}
response = render_to_response(self.ERROR_TEMPLATE, data, RequestContext(request))
response.status_code = 500 # server error.
return response
except Exception, exc:
logging.error("Failed to render error page: %s" % exc)
logging.exception(exc)
return None
# EOF
| zzheng | zhengzhong/website/zheng/common/middlewares.py | Python | asf20 | 3,617 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-04-14.
# $Id$
#
import re
__all__ = ("Browser",)
_BROWSERS = (
# Opera likes to pretend to be some other browser, so detect it first.
(re.compile(r"(?P<id>Opera)[/\s](?P<version>[\w\.\-]+)"), "Opera"),
(re.compile(r"(?P<id>MSIE)\s(?P<version>[\w\.\-]+)"), "Microsoft Internet Explorer"),
(re.compile(r"(?P<id>Firefox)/(?P<version>[\w\.\-]+)"), "Mozilla Firefox"),
(re.compile(r"(?P<id>Chrome)/(?P<version>[\w\.\-]+)"), "Google Chrome"),
(re.compile(r"(?P<id>Safari)/(?P<version>[\w\.\-]+)"), "Safari"),
)
def _parse_browser(user_agent):
user_agent = user_agent or ""
for expr, browser_name in _BROWSERS:
match = expr.search(user_agent)
if match:
return (match.group("id"), browser_name, match.group("version"))
return (None, None, None)
def _parse_platform(user_agent):
user_agent = user_agent or ""
expr = re.compile(r"(?P<platform>Windows|Linux|Mac\sOS\sX|FreeBSD|OpenBSD)")
match = expr.search(user_agent)
if match:
return match.group("platform")
else:
return None
class Browser(object):
def __init__(self, user_agent):
self.user_agent = user_agent or None
self.id, self.name, self.version = _parse_browser(user_agent)
self.platform = _parse_platform(user_agent)
def __str__(self):
return "%s %s (%s)" % (self.name, self.version, self.platform)
def __unicode__(self):
return u"%s %s (%s)" % (self.name, self.version, self.platform)
# EOF
| zzheng | zhengzhong/website/zheng/common/browsers.py | Python | asf20 | 1,698 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-02-09.
# $Id$
#
import datetime
from platform import python_version
from django import get_version as django_version
from django.conf import settings
from django.http import HttpRequest
from zheng import get_version as website_version
from zheng.common import users
from zheng.common.browsers import Browser
_GOOGLE_AJAX_API_KEYS = {
"www.zhengzhong.net": "ABQIAAAA6SC56e9JfGUas7BsUDqyuBQTYCh4nfnZskh9tX3CKbKESYY0QBQRDfWUx_P2DPVUCiFC7DmMx_qv6A",
}
def common_data_processor(request):
server_name = request.META.get("SERVER_NAME")
google_ajax_api_key = _GOOGLE_AJAX_API_KEYS.get(server_name, "")
return {
"site_name_": getattr(settings, "MY_SITE_NAME", None),
"static_": getattr(settings, "MY_STATIC_URL_PREFIX", ""),
"browser_": Browser(request.META.get("HTTP_USER_AGENT")),
"server_name_": server_name,
"google_ajax_api_key_": google_ajax_api_key,
"today_": datetime.date.today(),
}
def current_user_processor(request):
user = users.get_current_user(request)
if not user:
login_url = users.create_login_url(request.path)
logout_url = None
else:
login_url = None
logout_url = users.create_logout_url(request.path)
return {
"user_": user,
"user_ip_": request.META["REMOTE_ADDR"],
"login_url_": login_url,
"logout_url_": logout_url,
"is_webmaster_": users.is_webmaster(user),
}
def powered_by_processor(request):
return {
"website_version_": website_version(),
"python_version_": python_version(),
"django_version_": django_version(),
}
# EOF
| zzheng | zhengzhong/website/zheng/common/context_processors.py | Python | asf20 | 1,839 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-02-08.
# $Id$
#
import urllib
from django.http import HttpRequest
class Prompt(object):
INFO = "info"
ERROR = "error"
def __init__(self, **kwargs):
self.severity = None
self.message = None
if kwargs.get("request"):
request_dict = kwargs["request"].REQUEST
else:
request_dict = kwargs
if request_dict.get(Prompt.ERROR):
self.severity = Prompt.ERROR
self.message = request_dict[Prompt.ERROR]
elif request_dict.get(Prompt.INFO):
self.severity = Prompt.INFO
self.message = request_dict[Prompt.INFO]
def __nonzero__(self):
return bool(self.message)
def __str__(self):
return str(self.message)
def __unicode__(self):
return unicode(self.message)
@property
def id(self):
return "prompt-%s-%d" % (self.severity, abs(hash(self.message)))
def as_dict(self):
if self.severity and self.message:
return {self.severity: self.message}
else:
return {}
def urlencode(self):
return urllib.urlencode(self.as_dict())
# EOF
| zzheng | zhengzhong/website/zheng/common/prompt.py | Python | asf20 | 1,340 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-02-08.
# $Id$
#
from django.http import HttpRequest, HttpResponse, HttpResponseRedirect
from django.template import RequestContext
from django.shortcuts import render_to_response
from django.core.urlresolvers import reverse
from zheng.common import users
from zheng.common.errors import ProgrammingError, BadRequestError
__all__ = ("Action", "WebmasterAction",)
class Action(object):
PAGE_URL_NAME = None
PAGE_TEMPLATE = None
AJAX_URL_NAME = None
AJAX_TEMPLATE = None
def __init__(self, request):
self._request = request
@property
def name(self):
return self.__class__.__name__
@property
def request(self):
return self._request
def get_page_template(self):
return self.PAGE_TEMPLATE
def get_ajax_template(self):
return self.AJAX_TEMPLATE
@property
def current_user(self):
return users.get_current_user(self.request)
def process(self):
is_ajax = self.request.is_ajax() or (self.request.REQUEST.get("ajax") == "ajax")
if is_ajax:
return self.process_ajax()
else:
return self.process_page()
def process_ajax(self):
if self.request.method == "GET":
data = self.get_ajax()
elif self.request.method == "POST":
data = self.post_ajax()
else:
message = "%s does not support AJAX %s request." % (self.name, self.request.method)
raise BadRequestError(self.request, message)
data = self.update_data(data)
return render_to_response(self.get_ajax_template(), data, RequestContext(self.request))
def process_page(self):
if self.request.method == "GET":
return self.get_page()
elif self.request.method == "POST":
return self.post_page()
else:
message = "%s does not support %s request." % (self.name, self.request.method)
raise BadRequestError(self.request, message)
def update_data(self, data):
return data
def get_page(self):
message = "%s does not support GET request." % self.name
raise BadRequestError(self.request, message)
def post_page(self):
message = "%s does not support POST request." % self.name
raise BadRequestError(self.request, message)
def get_ajax(self):
message = "%s does not support AJAX GET request." % self.name
raise BadRequestError(self.request, message)
def post_ajax(self):
message = "%s does not support AJAX POST request." % self.name
raise BadRequestError(self.request, message)
@classmethod
def get_page_url(cls, **kwargs):
if not cls.PAGE_URL_NAME:
message = "Failed to get page URL for %s: PAGE_URL_NAME not defined." % cls.__name__
raise ProgrammingError(message)
return reverse(cls.PAGE_URL_NAME, kwargs=kwargs)
@classmethod
def get_ajax_url(cls, **kwargs):
if not cls.AJAX_URL_NAME:
message = "Failed to get AJAX URL for %s: AJAX_URL_NAME not defined." % cls.__name__
raise ProgrammingError(message)
return reverse(cls.AJAX_URL_NAME, kwargs=kwargs)
class WebmasterAction(Action):
def process(self):
if not users.is_webmaster(self.current_user):
message = "The action '%s' is restricted to webmasters." % self.name
raise BadRequestError(self.request, message)
else:
return super(WebmasterAction, self).process()
# EOF
| zzheng | zhengzhong/website/zheng/common/actions.py | Python | asf20 | 3,779 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2009-10-29.
# $Id$
#
| zzheng | zhengzhong/website/zheng/common/__init__.py | Python | asf20 | 150 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-05-07.
# $Id$
#
from __future__ import absolute_import # PEP 328
import logging
from django.conf import settings
from google.appengine.api import users
__all__ = (
"User",
"get_current_user",
"create_login_url",
"create_logout_url",
"get_user",
"is_webmaster",
)
class User(object):
def __init__(self, user):
self._user = user
def __unicode__(self):
return unicode(self.username)
def __str__(self):
return unicode(self).encode("utf-8")
def __nonzero__(self):
return self._user is not None
@property
def username(self):
if self._user is not None:
return self._user.nickname()
return None
@property
def email(self):
if self._user is not None:
return self._user.email()
return None
def is_anonymous(self):
return self._user is None
def is_authenticated(self):
return self._user is not None
def get_current_user(request):
google_user = users.get_current_user()
return User(google_user)
def create_login_url(dest_url):
return users.create_login_url(dest_url)
def create_logout_url(dest_url):
return users.create_logout_url(dest_url)
def get_user(username):
username = username.strip()
if "@" in username:
email = username
else:
email_domain = getattr(settings, "MY_EMAIL_DOMAIN")
email = "%s@%s" % (username, email_domain)
google_user = users.User(email)
return User(google_user)
def is_webmaster(user):
if not user:
return False
else:
webmaster_emails = getattr(settings, "MY_WEBMASTER_EMAILS", ())
return user.email in webmaster_emails
# EOF
| zzheng | zhengzhong/website/zheng/common/users.py | Python | asf20 | 1,853 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2009-10-29.
# $Id$
#
__all__ = ("Error", "ProgrammingError", "BadRequestError", "InvalidFormError",)
class Error(Exception): pass
class ProgrammingError(Error): pass
class EntityNotFoundError(Error):
def __init__(self, model_class, searched_by):
message = u"%s not found: %s" % (model_class.__name__, searched_by)
super(EntityNotFoundError, self).__init__(message)
class InvalidFormError(Error):
def __init__(self, errors):
bad_fields = u", ".join(errors.keys())
message = u"Invalid value(s) in field(s): %s." % bad_fields
super(InvalidFormError, self).__init__(message)
class BadRequestError(Error):
def __init__(self, request, message):
super(BadRequestError, self).__init__(message)
self._path = request.path
self._method = request.method
@property
def path(self):
return self._path
@property
def method(self):
return self._method
# EOF
| zzheng | zhengzhong/website/zheng/common/errors.py | Python | asf20 | 1,135 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-02-08.
# $Id$
#
import datetime
import logging
import random
__all__ = ("filter_key", "ord_to_key", "generate_key")
def _is_valid_key(s):
if s.isdigit():
return True
elif s.lower() >= "a" and s.lower() <= "z":
return True
elif s == "-" or s == "." or s == "@" or s == "_":
return True
else:
return False
def filter_key(name, min_length=None, reserved=None, force_lower=True):
reserved = reserved or []
pk = filter(_is_valid_key, str(name))
if force_lower:
pk = pk.lower()
if min_length and len(pk) < min_length:
raise ValueError("'%s' is too short." % pk)
if pk in reserved:
raise ValueError("'%s' is reserved." % pk)
return pk
def ord_to_key(name, separator=None):
separator = separator or "-"
ord_list = ["%x" % ord(c) for c in name if not c.isspace()]
return separator.join(ord_list)
def generate_key(max_rand=None):
max_rand = max_rand or 0xFFFF
timestamp = datetime.datetime.now().strftime("%Y%m%d%H%M%S")
rand_suffix = "%4X" % random.randint(0, max_rand)
return "%sX%s" % (timestamp, rand_suffix)
# EOF
| zzheng | zhengzhong/website/zheng/common/dbutils.py | Python | asf20 | 1,328 |
#!/usr/bin/env python
from django.core.management import execute_manager
try:
import settings # Assumed to be in the same directory.
except ImportError:
import sys
sys.stderr.write("Error: Can't find the file 'settings.py' in the directory containing %r. It appears you've customized things.\nYou'll have to run django-admin.py, passing it your settings module.\n(If the file settings.py does indeed exist, it's causing an ImportError somehow.)\n" % __file__)
sys.exit(1)
if __name__ == "__main__":
execute_manager(settings)
| zzheng | zhengzhong/website/zheng/manage.py | Python | asf20 | 557 |
/**
* Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
*
* AJAX utility functions. This file requires the jQuery library.
*
* Created on 2010-02-11.
* $Id$
*/
var friday = {
// Toggles the AJAX mode in an AJAX box identified by ajax_box_id.
// @param ajax_box_id
toggle: function(ajax_box_id) {
$(ajax_box_id + " .ajax-view").toggle();
$(ajax_box_id + " .ajax-edit").toggle();
},
// Submits an AJAX form.
// @param ajax_box_id
// @param ajax_form_id
submitAjaxForm: function(ajax_box_id, ajax_form_id) {
var ajax_box = $(ajax_box_id);
var ajax_form = $(ajax_form_id);
// Prepare the AJAX request options.
var options = {
type: ajax_form.attr("method"),
url: ajax_form.attr("action"),
data: ajax_form.serialize(),
success: function(data) {
ajax_box.after(data).remove();
},
error: function(xhr, status, exc) {
$("input[type='submit']", ajax_form).removeAttr("disabled");
$(".ajax-error", ajax_box).show();
}
};
// Before sending AJAX request...
$("input[type='submit']", ajax_form).attr("disabled", "disabled");
$(".ajax-error", ajax_box).hide();
// Send AJAX request...
$.ajax(options);
// Return false, to disable default behavior.
return false;
},
showMap: function(lat, lon, container_id) {
var MAP_ZOOM = 16;
if (GBrowserIsCompatible()) {
var geo_pt = new GLatLng(lat, lon);
var marker = new GMarker(geo_pt);
var container = $(container_id).get(0);
var map = new GMap2(container);
map.addControl(new GLargeMapControl());
map.setCenter(geo_pt, MAP_ZOOM);
map.addOverlay(marker);
}
},
findInMap: function(address, container_id, on_found, on_not_found) {
var MAP_ZOOM = 16;
var geocoder = new GClientGeocoder();
if (geocoder) {
geocoder.getLatLng(
address,
function(geo_pt) {
if (!geo_pt) {
on_not_found(address);
} else {
var marker = new GMarker(geo_pt, {draggable: true});
var container = $(container_id).get(0);
var map = new GMap2(container);
map.addControl(new GLargeMapControl());
map.setCenter(geo_pt, MAP_ZOOM);
GEvent.addListener(marker, "dragend", function(lat_lon) {
on_found(lat_lon.lat(), lat_lon.lng());
});
map.addOverlay(marker);
on_found(geo_pt.lat(), geo_pt.lng());
}
}
);
}
},
dummy: function() {
alert("dummy() called!");
return false;
}
} // namespace friday
| zzheng | friday/website/static/js/friday.js | JavaScript | asf20 | 3,181 |
/**
Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
Created on 2008-12-03.
$Id$
*/
/*--------------------------------------------------------------------------------------------------
* HTML elements
*------------------------------------------------------------------------------------------------*/
body {
margin: 0;
padding: 0;
text-align: center;
font: normal normal 80% Arial,Helvetica,sans-serif;
}
a, a:link, a:visited {
text-decoration: none;
color: #2090D0;
}
a:hover {
text-decoration: underline;
color: #2090D0;
}
a img {
border-width: 0;
}
h1, h2, h3 {
margin: 0;
padding: 8px 0 8px 0;
}
h1 {
font-weight: bold;
font-size: 160%;
}
h2 {
font-weight: normal;
font-size: 130%;
color: #666666;
}
h3 {
font-weight: normal;
font-size: 110%;
}
h5 {
margin: 0;
padding: 4px;
font-weight: normal;
font-size: 110%;
color: #666666;
text-align: right;
border-top: solid 1px #DDDDDD;
}
p, .p {
margin: 0;
padding: 4px 0 4px 0;
}
ul, ol {
margin: 0;
padding: 4px 0 4px 20px;
}
tt, code, pre, .code {
font-family: 'Courier New',courier,arial, sans-serif;
}
pre {
margin: 4px 0 4px 0;
padding: 4px;
border: solid 1px #888888;
}
fieldset {
margin: 8px 0 8px 0;
padding: 8px;
border: 1px solid #BBBBBB;
border-radius: 4px;
-moz-border-radius: 4px;
-webkit-border-radius: 4px;
}
fieldset legend {
color: #666666;
font-weight: normal;
font-size: 110%;
}
/*--------------------------------------------------------------------------------------------------
* no-ie-wrapper
*------------------------------------------------------------------------------------------------*/
#no-ie-wrapper {
margin: 0;
padding: 2px;
text-align: center;
background-color: #FAFDCE;
border-bottom: 1px solid #FACC00;
}
/*--------------------------------------------------------------------------------------------------
* outer-wrapper
*------------------------------------------------------------------------------------------------*/
#outer-wrapper {
margin: 0 auto;
padding: 0;
text-align: left;
width: 990px;
min-width: 990px;
border: 1px solid #DDDDDD;
}
/*--------------------------------------------------------------------------------------------------
* topbar-wrapper and footer-wrapper
*------------------------------------------------------------------------------------------------*/
#topbar-wrapper, #footer-wrapper {
margin: 0;
padding: 10px;
line-height: 1.4em;
color: #888888;
}
#topbar-wrapper .topbar-logo, #footer-wrapper .footer-left {
float: left;
white-space: nowrap;
}
#topbar-wrapper .topbar-text, #footer-wrapper .footer-right {
float: right;
text-align: right;
white-space: nowrap;
}
#footer-wrapper {
font-size: 90%;
border-top: 1px solid #DDDDDD;
}
#footer-wrapper a {
color: #888888;
}
/*--------------------------------------------------------------------------------------------------
* banner-wrapper (simple and exotic)
*------------------------------------------------------------------------------------------------*/
#banner-wrapper {
margin: 0;
padding: 0;
}
#banner-wrapper .simple {
margin: 0;
padding: 0;
}
#banner-wrapper .exotic {
margin: 0;
padding: 0;
width: 990px;
min-width: 990px;
height: 160px;
overflow: hidden;
position: relative;
}
#banner-wrapper .simple img.background {
display: none;
}
#banner-wrapper .exotic img.background {
display: block;
position: absolute;
width: 990px;
min-width: 990px;
top: 0;
left: 0;
border: 0;
}
#banner-wrapper .banner-opaque {
margin: 0;
padding: 0;
}
#banner-wrapper .simple .banner-opaque {
}
#banner-wrapper .exotic .banner-opaque {
width: 990px;
min-width: 990px;
height: 70px;
float: left;
position: absolute;
top: 70px;
background: #000000;
opacity: 0.5;
filter: alpha(opacity=50); /* for IE */
}
#banner-wrapper .banner-text {
margin: 0;
padding: 0;
width: 100%;
}
#banner-wrapper .simple .banner-text {
}
#banner-wrapper .exotic .banner-text {
height: 70px;
float: left;
position: absolute;
top: 70px;
}
#banner-wrapper .banner-text img.icon {
padding: 0;
padding: 10px 10px 4px 10px;
width: 48px;
height: 48px;
display: inline;
float: left;
}
#banner-wrapper .banner-text h1 {
margin: 0;
padding: 10px 10px 4px 10px;
font-weight: bold;
font-size: 160%;
}
#banner-wrapper .banner-text h2 {
margin: 0;
padding: 0 10px 4px 10px;
font-weight: normal;
font-size: 110%;
}
#banner-wrapper .banner-text .links {
margin: 0;
padding: 0 10px 10px 10px;
font-size: 90%;
}
#banner-wrapper .simple .banner-text h1,
#banner-wrapper .simple .banner-text h1 a,
#banner-wrapper .simple .banner-text h2,
#banner-wrapper .simple .banner-text h2 a {
color: #2060B0;
}
#banner-wrapper .simple .banner-text .links {
color: #888888;
}
#banner-wrapper .exotic .banner-text h1,
#banner-wrapper .exotic .banner-text h2,
#banner-wrapper .exotic .banner-text a,
#banner-wrapper .exotic .banner-text .links {
color: #FFFFFF;
}
/*--------------------------------------------------------------------------------------------------
* navbar-wrapper
*------------------------------------------------------------------------------------------------*/
#navbar-wrapper {
margin: 0;
padding: 0;
}
#navbar-wrapper .menutabs {
margin: 0;
padding: 4px 10px 4px 10px;
text-align: right;
color: #888888;
border-bottom: 1px solid #DDDDDD;
}
#navbar-wrapper .menutabs a {
padding: 2px 4px 2px 4px;
text-decoration: none;
border: 1px solid transparent;
border-radius: 4px;
-moz-border-radius: 4px;
-webkit-border-radius: 4px;
}
#navbar-wrapper .menutabs a:hover {
text-decoration: none;
background-color: #E8EEFA;
border-color: #C3D9FF;
}
#navbar-wrapper .navigator {
margin: 0;
padding: 4px 10px 4px 10px;
border-bottom: 1px solid #DDDDDD;
}
/*--------------------------------------------------------------------------------------------------
* main-wrapper, sidebar-wrapper and content-wrapper
*------------------------------------------------------------------------------------------------*/
#main-wrapper {
margin: 0;
padding: 10px;
}
#sidebar-wrapper {
margin: 0;
padding: 0;
display: inline;
float: right;
width: 30%;
overflow: hidden;
color: #444444;
}
#sidebar-wrapper h2 a, #sidebar-wrapper h3 a {
color: #444444;
}
#sidebar-wrapper dl {
margin: 0;
padding: 4px 0 4px 0;
}
#sidebar-wrapper dt {
margin: 0;
padding: 0 0 2px 0;
font-weight: bold;
}
#sidebar-wrapper dd {
margin: 0;
padding: 0 0 0 20px;
}
#sidebar-wrapper .input input,
#sidebar-wrapper .input textarea,
#sidebar-wrapper .input select,
#sidebar-wrapper .input select option {
color: #444444;
}
#sidebar-wrapper .huge {
margin: 0 0 8px 0;
padding: 8px;
text-align: center;
font-weight: bold;
font-size: 400%;
background-color: #EEEEEE;
border: 1px solid #BBBBBB;
border-radius: 8px;
-moz-border-radius: 8px;
-webkit-border-radius: 8px;
}
#sidebar-wrapper ul {
margin: 0;
padding: 0 0 0 20px;
}
#content-wrapper {
margin: 0;
padding: 0;
display: inline;
float: left;
width: 68%;
}
#main-wrapper h1 {
color: #FF0080;
}
| zzheng | friday/website/static/css/layout.css | CSS | asf20 | 7,656 |
/**
Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
Created on 2008-12-03.
$Id$
*/
.table {
margin: 0;
padding: 4px 0 4px 0;
width: 100%;
}
.table th, .table td {
margin: 0;
padding: 4px;
text-align: left;
line-height: 1.2em;
}
.table thead th {
color: #666666;
font-weight: normal;
border-bottom: 1px solid #BBBBBB;
}
.table tr.highlighted td {
background-color: #FFFFCC;
}
.zebra tbody tr.odd {
background-color: #FFFFFF;
}
.zebra tbody tr.even {
background-color: #E8E8E8;
}
.zebra tbody tr.odd:hover, .zebra tbody tr.even:hover {
background-color: #FFFFDD;
}
.table-info {
margin: 0;
padding: 4px 8px 4px 8px;
text-align: right;
color: #666666;
}
| zzheng | friday/website/static/css/table.css | CSS | asf20 | 768 |
/**
Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
Created on 2008-12-03.
$Id$
*/
/*--------------------------------------------------------------------------------------------------
* HTML elements
*------------------------------------------------------------------------------------------------*/
body {
margin: 0 auto;
padding: 0;
text-align: center;
font: normal normal 80% Arial,Helvetica,sans-serif;
}
a, a:link, a:visited {
text-decoration: none;
color: #2090D0;
}
a:hover {
text-decoration: underline;
color: #2090D0;
}
a img {
border-width: 0;
}
h1, h2, h3 {
margin: 0;
padding: 8px 0 8px 0;
}
h1 {
font-weight: bold;
font-size: 160%;
}
h2 {
font-weight: normal;
font-size: 130%;
color: #666666;
}
h3 {
font-weight: normal;
font-size: 110%;
}
h5 {
margin: 0;
padding: 4px;
font-weight: normal;
font-size: 110%;
color: #666666;
text-align: right;
border-top: solid 1px #DDDDDD;
}
.clear {
clear: both;
}
/*--------------------------------------------------------------------------------------------------
* home-wrapper
*------------------------------------------------------------------------------------------------*/
#home-wrapper {
margin: 0 auto;
padding: 0;
text-align: left;
width: 990px;
min-width: 990px;
/*border: 1px solid #DDDDDD;*/
}
/*--------------------------------------------------------------------------------------------------
* topbar-wrapper and footer-wrapper
*------------------------------------------------------------------------------------------------*/
#topbar-wrapper {
margin: 0;
padding: 10px;
line-height: 1.4em;
color: #888888;
border-bottom: 1px solid #DDDDDD;
}
#footer-wrapper {
margin: 0;
padding: 10px;
line-height: 1.4em;
color: #888888;
font-size: 90%;
border-top: 1px solid #DDDDDD;
}
#footer-wrapper a {
color: #888888;
}
#footer-wrapper .footer-left {
float: left;
white-space: nowrap;
}
#footer-wrapper .footer-right {
float: right;
text-align: right;
white-space: nowrap;
}
/*--------------------------------------------------------------------------------------------------
* main-wrapper
*------------------------------------------------------------------------------------------------*/
#main-wrapper {
margin: 0;
padding: 40px 10px 40px 10px;
font-size: 110%;
}
#splash {
margin: 0;
padding: 10px 0 10px 0;
display: inline;
float: left;
width: 560px;
overflow: hidden;
color: #444444;
}
#splash .image {
margin: 0;
padding: 2px;
border: 1px solid #BBBBBB;
width: 540px;
}
#splash .alt {
margin: 0;
padding: 2px;
width: 540px;
text-align: right;
font-size: 90%;
color: #888888;
}
#splash .alt a {
color: #888888;
}
#text {
margin: 40px auto;
padding: 0;
text-align: center;
display: inline;
float: right;
width: 400px;
}
.big {
margin: 0;
padding: 0 0 10px 0;
color: #888888;
font: normal bold 240% Garamond,Arial,Helvetica,sans-serif;
white-space: nowrap;
}
.bigger {
margin: 0;
padding: 0 0 60px 0;
color: #888888;
font: normal bold 320% Garamond,Arial,Helvetica,sans-serif;
white-space: nowrap;
}
a.button {
padding: 8px 20px 8px 20px;
font-weight: bold;
font-size: 100%;
text-decoration: none;
background-color: #2090D0;
color: #FFFFFF;
border: none;
border-radius: 4px;
-moz-border-radius: 4px;
-webkit-border-radius: 4px;
}
a.button:hover {
text-decoration: none;
background-color: #2060B0;
color: #FFFFFF;
border: none;
}
| zzheng | friday/website/static/css/welcome.css | CSS | asf20 | 3,746 |
/**
Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
Created on 2008-12-03.
$Id$
*/
/*--------------------------------------------------------------------------------------------------
* common CSS classes
*------------------------------------------------------------------------------------------------*/
.big {
font-size: 110%;
}
.aux {
color: #666666;
}
.na {
color: #666666;
}
.hidden {
display: none;
}
.right {
display: inline;
float: right;
}
.left {
display: inline;
float: left;
}
.clear {
clear: both;
}
.nowrap {
white-space: nowrap;
}
img.icon {
vertical-align: text-bottom;
}
/*--------------------------------------------------------------------------------------------------
* AJAX styles
*------------------------------------------------------------------------------------------------*/
.ajax-loader, .ajax-error {
margin: 8px 0 8px 0;
padding: 8px;
color: #666666;
border-width: 1px;
border-style: solid;
border-radius: 4px;
-moz-border-radius: 4px;
-webkit-border-radius: 4px;
}
.ajax-loader {
background-color: #E8EEFA;
border-color: #C3D9FF;
}
.ajax-error {
background-color: #FAFDCE;
border-color: #FACC00;
}
/*--------------------------------------------------------------------------------------------------
* Prompt
*------------------------------------------------------------------------------------------------*/
.info-prompt, .error-prompt {
margin: 10px 0 10px 0;
padding: 10px;
border-radius: 4px;
-moz-border-radius: 4px;
-webkit-border-radius: 4px;
}
.info-prompt {
background-color: #E8EEFA;
border: 1px solid #C3D9FF;
}
.error-prompt {
background-color: #FAFDCE;
border: 1px solid #FACC00;
}
/*--------------------------------------------------------------------------------------------------
* sections
*------------------------------------------------------------------------------------------------*/
.section {
margin: 0;
padding: 0 0 20px 0;
line-height: 1.4em;
}
/*--------------------------------------------------------------------------------------------------
* posts
*------------------------------------------------------------------------------------------------*/
.post {
margin: 0;
padding: 8px 0 8px 0;
border-bottom: 1px dotted #BBBBBB;
}
.post .post-head,
.post .post-body,
.post .post-foot {
margin: 0;
padding: 0 0 4px 0;
line-height: 1.4em;
}
.post .post-head {
font-size: 110%;
}
.post .post-head p {
margin: 0;
padding: 0;
}
.post .post-body {
color: #666666;
}
.post .post-foot {
color: #666666;
}
/*--------------------------------------------------------------------------------------------------
* pagination
*------------------------------------------------------------------------------------------------*/
.pagination {
margin: 0;
padding: 8px;
text-align: right;
}
.pager {
margin: 0;
padding: 4px;
}
/*--------------------------------------------------------------------------------------------------
* progress bar
*------------------------------------------------------------------------------------------------*/
table.progress {
margin: 0 8px 0 0;
padding: 0;
border-spacing: 0;
border: 1px solid #BBBBBB;
empty-cells: show;
float: left;
}
table.progress td a, table.progress td span {
display: block;
height: 1.2em;
text-decoration: none;
}
table.progress td :hover {
/*background-color: red;*/
}
table.progress td {
margin: 0;
padding: 0;
}
table.progress td.on {
background-color: #C3D9FF;
}
table.progress td.off {
background-color: #FFFFFF;
}
/*--------------------------------------------------------------------------------------------------
* tags
*------------------------------------------------------------------------------------------------*/
.tags {
margin: 0;
padding: 4px 0 4px 0;
}
.tags ul li {
text-indent: -16px;
list-style: none outside none;
}
.tag-cloud {
margin: 0;
padding: 4px 0 4px 0;
}
.tag-cloud .tag {
margin: 0;
padding: 0 4px 0 0;
}
a.remove-tag {
padding: 0 4px 0 4px;
font-weight: bold;
text-decoration: none;
color: #888888;
}
a.remove-tag:hover {
text-decoration: none;
color: #FF0080;
}
.removed-tag {
color: #888888;
}
/*--------------------------------------------------------------------------------------------------
* jQuery UI widget
*------------------------------------------------------------------------------------------------*/
.ui-widget {
font: normal normal 100% Arial,Helvetica,sans-serif;
}
/*--------------------------------------------------------------------------------------------------
* Photo style
*------------------------------------------------------------------------------------------------*/
.s-photo {
margin: 4px 0 4px 0;
padding: 2px;
width: 280px;
border: 1px solid #BBBBBB;
}
.xs-photo {
margin: 0;
padding: 2px;
width: 200px;
border: 1px solid #BBBBBB;
}
/*--------------------------------------------------------------------------------------------------
* Google Maps canvas style
*------------------------------------------------------------------------------------------------*/
.map {
margin: 8px 0 8px 0;
padding: 0;
width: 600px;
height: 400px;
border: 1px solid #BBBBBB;
}
.s-map {
margin: 4px 0 4px 0;
padding: 0;
width: 280px;
height: 280px;
border: 1px solid #BBBBBB;
}
| zzheng | friday/website/static/css/common.css | CSS | asf20 | 5,696 |
/**
Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
Created on 2010-02-10.
$Id$
*/
/*--------------------------------------------------------------------------------------------------
* common styles applied to all kinds of forms
*------------------------------------------------------------------------------------------------*/
.required input, .required textarea, .required select {
background-color: #FFFFDD;
}
.disabled-value {
color: #666666;
background-color: #DDDDDD;
}
.label, .input, .radio, .checkbox, .error-list, .help-text {
margin: 0;
padding: 4px 0 4px 0;
}
.error-list {
color: #FF0000;
}
.error-list ul {
margin: 0;
padding: 0;
}
.error-list li {
margin: 0;
padding: 0;
text-indent: 0;
list-style: none outside none;
}
.help-text {
color: #888888;
}
.input textarea,
.input input,
.input select,
.disabled-value {
margin: 0;
padding: 4px;
font-size: 100%;
border: 1px solid #BBBBBB;
border-radius: 4px;
-moz-border-radius: 4px;
-webkit-border-radius: 4px;
}
.input textarea {
font-family: 'Courier New',courier,arial, sans-serif;
}
.input select option {
font-size: 100%;
font-family: Arial,Helvetica,sans-serif;
}
.h1-input textarea, .h1-input input {
font-weight: bold;
font-size: 160%;
}
.radio input, .checkbox input {
padding: 0 0 0 10px;
}
.radio ul {
margin: 0;
padding: 0;
}
.radio li {
margin: 0;
padding: 0;
text-indent: 0;
list-style: none outside none;
}
input.button, a.button {
padding: 2px 4px 2px 4px;
font-weight: bold;
font-size: 100%;
text-decoration: none;
background-color: #2090D0;
color: #FFFFFF;
border: none;
border-radius: 4px;
-moz-border-radius: 4px;
-webkit-border-radius: 4px;
}
input.button:hover, a.button:hover {
text-decoration: none;
background-color: #2060B0;
color: #FFFFFF;
border: none;
}
/*--------------------------------------------------------------------------------------------------
* small-sized (S) form
*------------------------------------------------------------------------------------------------*/
.xs-form {
margin: 0;
padding: 4px 0 4px 0;
}
.xs-form .field {
margin: 0 0 4px 0;
padding: 0;
}
.xs-form .input textarea,
.xs-form .input input,
.xs-form .input select,
.xs-form .disabled-value {
width: 80px;
}
/*--------------------------------------------------------------------------------------------------
* small-sized (S) form
*------------------------------------------------------------------------------------------------*/
.s-form {
margin: 0;
padding: 4px 0 4px 0;
}
.s-form .field {
margin: 0 0 4px 0;
padding: 0;
}
.s-form .field .label {
font-weight: normal;
font-size: 110%;
}
.s-form .input textarea,
.s-form .input input,
.s-form .input select,
.s-form .disabled-value {
width: 200px;
}
/*--------------------------------------------------------------------------------------------------
* medium-sized (M) form
*------------------------------------------------------------------------------------------------*/
.m-form {
margin: 0;
padding: 4px 0 4px 0;
}
.m-form .field {
margin: 0 0 4px 0;
padding: 0;
}
.m-form .field .label {
font-weight: normal;
font-size: 110%;
}
.m-form .input textarea,
.m-form .input input,
.m-form .input select,
.m-form .disabled-value {
width: 400px;
}
/*--------------------------------------------------------------------------------------------------
* extra-large-sized (XL) form
*------------------------------------------------------------------------------------------------*/
.xl-form {
margin: 0;
padding: 4px 0 4px 0;
}
.xl-form .field {
margin: 0 0 20px 0;
padding: 0;
}
.xl-form .field .label {
font-weight: normal;
font-size: 130%;
}
.xl-form .input textarea,
.xl-form .input input,
.xl-form .input select,
.xl-form .disabled-value {
width: 90%;
}
| zzheng | friday/website/static/css/form.css | CSS | asf20 | 4,110 |
/**
Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
Created on 2010-02-19.
$Id$
*/
/*--------------------------------------------------------------------------------------------------
* user-avatar
*------------------------------------------------------------------------------------------------*/
.user-avatar a, .user-avatar a:hover {
white-space: nowrap;
text-decoration: none;
}
.user-avatar a img {
margin: 0;
padding: 2px;
width: 48px;
height: 48px;
border: 1px solid #BBBBBB;
}
.user-avatar a:hover img {
border: 1px solid #888888;
}
/*--------------------------------------------------------------------------------------------------
* user-list
*------------------------------------------------------------------------------------------------*/
.user-list {
margin: 0;
padding: 4px 0 4px 0;
}
.user-list .user {
margin: 0 auto;
padding: 0 10px 10px 0;
display: inline;
float: left;
text-align: center;
white-space: nowrap;
}
.user-list .user .user-avatar, .user-list .user .user-info {
text-align: center;
white-space: nowrap;
}
/*--------------------------------------------------------------------------------------------------
* user-box
*------------------------------------------------------------------------------------------------*/
.user-box {
margin: 0;
padding: 4px 0 4px 0;
}
.user-box .user-avatar {
margin: 0;
padding: 0 10px 4px 0;
display: inline;
float: left;
}
.user-box .user-info {
margin: 0;
padding: 4px 0 4px 0;
}
| zzheng | friday/website/static/css/user.css | CSS | asf20 | 1,608 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-02-05.
# $Id$
#
import os
os.environ["DJANGO_SETTINGS_MODULE"] = "friday.settings"
from djangomockup import bootstrap
from django.core.handlers.wsgi import WSGIHandler
from google.appengine.ext.webapp.util import run_wsgi_app
def main():
application = WSGIHandler()
run_wsgi_app(application)
if __name__ == "__main__":
main()
# EOF
| zzheng | friday/website/main.py | Python | asf20 | 507 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-04-30.
# $Id$
#
"""
Script for handling incoming email.
"""
import os
os.environ["DJANGO_SETTINGS_MODULE"] = "friday.settings"
from djangomockup import bootstrap
import email
import logging
import re
from google.appengine.api.mail import InboundEmailMessage
from google.appengine.ext.webapp import WSGIApplication
from google.appengine.ext.webapp.mail_handlers import InboundMailHandler
from google.appengine.ext.webapp.util import run_wsgi_app
from friday.apps.poststats.models import count_post
def _grab_emails(*args):
pattern = re.compile(r"[\w\-][\w\-\.]+@[\w\-][\w\-\.]+[a-zA-Z]{1,4}")
emails = set()
for arg in args:
if arg:
emails.update(pattern.findall(str(arg)))
return list(emails)
class IncomingEmailHandler(InboundMailHandler):
def receive(self, mail_message):
subject = getattr(mail_message, "subject", None)
poster_email = _grab_emails(getattr(mail_message, "sender", None))
if len(poster_email) != 1:
logging.error("Fail to handle incoming email: suspicious poster %s" % poster_email)
return
poster_email = poster_email[0]
to = getattr(mail_message, "to", None)
cc = getattr(mail_message, "cc", None)
recipients = _grab_emails(to, cc)
count_post(subject=subject, poster_email=poster_email, recipients=recipients)
def main():
application = WSGIApplication([IncomingEmailHandler.mapping()], debug=True)
run_wsgi_app(application)
if __name__ == "__main__":
main()
# EOF
| zzheng | friday/website/handle_incoming_email.py | Python | asf20 | 1,731 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-02-08.
# $Id$
#
import datetime
import logging
from google.appengine.ext import db
from djangomockup import models
from djangomockup.models.signals import pre_delete
from friday.auth import users
from friday.apps.groups.models import Group
class Activity(models.Model):
group = db.ReferenceProperty(Group, required=True)
title = db.StringProperty(required=True)
content = db.TextProperty(required=True)
date = db.DateProperty(required=True)
address = db.PostalAddressProperty()
city = db.StringProperty(required=True)
geo_pt = db.GeoPtProperty()
places = db.IntegerProperty()
related_link = db.LinkProperty()
is_closed = db.BooleanProperty(required=True, default=False)
submitter = db.ReferenceProperty(users.User, required=True)
submit_date = db.DateProperty(auto_now_add=True)
schema_version = db.IntegerProperty(required=True, default=1)
@property
def model_name(self):
return self.__class__.__name__
@property
def is_past(self):
return self.date < datetime.date.today()
@property
def attenders(self):
return Attender.find_by_activity(self)
@property
def headcount(self):
headcount = 0
for attender in self.attenders:
headcount += 1 + attender.with_friends
return headcount
def __unicode__(self):
return unicode(self.title)
@classmethod
def get_unique(cls, id, group):
try:
instance = cls.objects.get(id=id)
except cls.DoesNotExist:
instance = None
if instance is not None and instance.group.uid != group.uid:
instance = None
return instance
@classmethod
def create(cls, group, **kwargs):
return cls(group=group, **kwargs)
@classmethod
def find_all(cls, group, **kwargs):
query = cls.objects.filter(group=group).order_by("-date")
if kwargs.get("limit"):
query.set_limit(kwargs["limit"])
return query
@classmethod
def find_upcoming(cls, group, **kwargs):
today = datetime.date.today()
query = cls.objects.filter(group=group, date__gte=today).order_by("-date")
if kwargs.get("limit"):
query.set_limit(kwargs["limit"])
return query
class Attender(models.Model):
activity = db.ReferenceProperty(Activity, required=False)
user = db.ReferenceProperty(users.User, required=True)
with_friends = db.IntegerProperty(required=True, default=0)
schema_version = db.IntegerProperty(required=True, default=1)
def __unicode__(self):
return unicode(self.user)
@property
def username(self):
return self.user.username
@classmethod
def _make_pk(cls, activity, user):
return "%s/%s" % (activity.id, user.email.lower())
@classmethod
def create(cls, activity, user, **kwargs):
pk = cls._make_pk(activity, user)
if "with_friends" in kwargs and kwargs["with_friends"] is None:
del kwargs["with_friends"]
return cls(key_name=pk, activity=activity, user=user, **kwargs)
@classmethod
def get_unique(cls, activity, user):
pk = cls._make_pk(activity, user)
try:
instance = cls.objects.get(pk=pk)
except cls.DoesNotExist:
instance = None
return instance
@classmethod
def find_by_activity(cls, activity, **kwargs):
query = cls.objects.filter(activity=activity).order_by(kwargs.get("order_by") or "user")
return query
@classmethod
def delete_related(cls, activity):
deleted = 0
query = cls.objects.filter(activity=activity)
for instance in query:
instance.delete()
deleted += 1
return deleted
#---------------------------------------------------------------------------------------------------
def delete_related_attenders(sender, **kwargs):
if sender == Activity:
try:
activity = kwargs["instance"]
deleted = Attender.delete_related(activity=activity)
if deleted > 0:
logging.info("%s related attenders have been deleted successfully." % deleted)
except Exception, exc:
logging.error("Failed to delete related attenders of activity: %s" % exc)
logging.exception(exc)
pre_delete.connect(delete_related_attenders, sender=Activity)
# EOF
| zzheng | friday/website/friday/apps/activities/models.py | Python | asf20 | 4,721 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-02-08.
# $Id$
#
from friday.auth import users
from friday.apps.groups.access import GroupAccess
from friday.apps.activities.models import Activity, Attender
class ActivityAccess(object):
def __init__(self, activity, user):
self._activity = activity
self._user = user
self._group_access = GroupAccess(activity.group, user)
@property
def group_access(self):
return self._group_access
def can_edit(self):
if not self._user:
return False
if users.is_webmaster(self._user):
return True
return (self._activity.submitter == self._user)
def can_delete(self):
if not self._user:
return False
if users.is_webmaster(self._user):
return True
return (self._activity.submitter == self._user)
def can_attend(self):
if self._activity.is_past or self._activity.is_closed:
return False
if not self._user:
return False
if not self._group_access.member or not self._group_access.member.is_approved:
return False
if self._activity.places and self._activity.headcount >= self._activity.places:
return False
attender = Attender.get_unique(activity=self._activity, user=self._user)
return attender is None
def can_quit(self):
if self._activity.is_past:
return False
if not self._user:
return False
attender = Attender.get_unique(activity=self._activity, user=self._user)
return attender is not None
# EOF
| zzheng | friday/website/friday/apps/activities/access.py | Python | asf20 | 1,789 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-02-08.
# $Id$
#
import logging
from django import forms
from google.appengine.ext import db
from friday.common.errors import ProgrammingError, InvalidFormError
from friday.common.fields import GeoPtField
from friday.apps.activities.models import Activity
class ActivityForm(forms.Form):
title = forms.CharField(required=True)
content = forms.CharField(required=True, widget=forms.Textarea)
date = forms.DateField(required=True)
address = forms.CharField(required=False)
city = forms.CharField(required=True)
geo_pt = GeoPtField(required=False)
places = forms.IntegerField(required=False)
related_link = forms.URLField(required=False)
is_closed = forms.BooleanField(required=False)
def __init__(self, data=None, instance=None):
self._instance = instance
if instance:
initial = {
"title": instance.title,
"content": instance.content,
"date": instance.date,
"address": instance.address,
"city": instance.city,
"geo_pt": instance.geo_pt,
"places": instance.places,
"related_link": instance.related_link,
"is_closed": instance.is_closed,
}
else:
initial = None
super(ActivityForm, self).__init__(data=data, initial=initial)
@property
def instance(self):
return self._instance
def clean_address(self):
return self.cleaned_data["address"] or None
def clean_related_link(self):
return self.cleaned_data["related_link"] or None
def create(self, group, submitter):
if self._instance is not None:
message = "Failed to create activity: this form is bound to an existing activity."
raise ProgrammingError(message)
if not self.is_valid():
raise InvalidFormError(self.errors)
instance = Activity.create(group=group, submitter=submitter, **self.cleaned_data)
instance.save()
return instance
def update(self):
if self._instance is None:
message = "Failed to update activity: this form is not bound to an activity."
raise ProgrammingError(message)
if not self.is_valid():
raise InvalidFormError(self.errors)
for name, value in self.cleaned_data.items():
setattr(self._instance, name, value)
self._instance.save()
return self._instance
# EOF
| zzheng | friday/website/friday/apps/activities/forms.py | Python | asf20 | 2,709 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-02-08.
# $Id$
#
from django.conf.urls.defaults import *
from friday.apps.activities.views import *
urlpatterns = patterns("",
url(
r"^$",
view_all_activities,
name="friday.view_all_activities"
),
url(
r"^upcoming/$",
view_upcoming_activities,
name="friday.view_upcoming_activities"
),
url(
r"^create/$",
create_activity,
name="friday.create_activity"
),
url(
r"^(?P<activity_id>\d+)/$",
view_activity,
name="friday.view_activity"
),
url(
r"^(?P<activity_id>\d+)/edit/$",
edit_activity,
name="friday.edit_activity"
),
url(
r"^(?P<activity_id>\d+)/delete/$",
delete_activity,
name="friday.delete_activity"
),
url(
r"^(?P<activity_id>\d+)/attenders/$",
view_attenders,
name="friday.view_attenders"
),
)
# EOF
| zzheng | friday/website/friday/apps/activities/urls.py | Python | asf20 | 1,117 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-02-08.
# $Id$
#
| zzheng | friday/website/friday/apps/activities/__init__.py | Python | asf20 | 150 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-02-08.
# $Id$
#
import logging
from django.http import HttpRequest, HttpResponse, HttpResponseRedirect
from django.template import RequestContext
from django.shortcuts import render_to_response
from friday.common.errors import BadRequestError, InvalidFormError, EntityNotFoundError
from friday.common.prompt import Prompt
from friday.apps.groups.models import Group, Member
from friday.apps.groups.views import BaseGroupAction
from friday.apps.activities.models import Activity, Attender
from friday.apps.activities.access import ActivityAccess
from friday.apps.activities.forms import ActivityForm
from friday.apps.activities.notifiers import activity_created
class ViewAllActivities(BaseGroupAction):
PAGE_URL_NAME = "friday.view_all_activities"
PAGE_TEMPLATE = "activities/view_all_activities.html"
def get_page(self):
data = {"activities": Activity.find_all(self.get_group())}
data = self.update_data(data)
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
class ViewUpcomingActivities(BaseGroupAction):
AJAX_URL_NAME = "friday.view_upcoming_activities"
AJAX_TEMPLATE = "activities/common/activities.html"
def get_ajax(self):
return {"activities": Activity.find_upcoming(self.get_group())}
class CreateActivity(BaseGroupAction):
PAGE_URL_NAME = "friday.create_activity"
PAGE_TEMPLATE = "activities/create_activity.html"
def _check_create_access(self):
if not self.get_group_access().can_contribute():
message = "Current user cannot create activity in group %s." % self.get_group().uid
logging.error(message)
raise BadRequestError(self.request, message)
def get_page(self):
self._check_create_access()
data = {"activity_form": ActivityForm()}
data = self.update_data(data)
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
def post_page(self):
self._check_create_access()
activity_form = ActivityForm(data=self.request.POST)
try:
activity = activity_form.create(group=self.get_group(), submitter=self.current_user)
message = "Activity #%d has been created successfully." % activity.id
logging.info(message)
activity_created(activity)
prompt = Prompt(info=message)
redirect_url = ViewActivity.get_page_url(
group_uid=self.get_group().uid,
activity_id=activity.id
)
redirect_url += "?" + prompt.urlencode()
return HttpResponseRedirect(redirect_url)
except Exception, exc:
message = "Failed to create activity in datastore: %s" % exc
logging.error(message)
logging.exception(exc)
data = {"activity_form": activity_form, "prompt": Prompt(error=message)}
data = self.update_data(data)
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
class BaseActivityAction(BaseGroupAction):
def __init__(self, request, group_uid, activity_id):
super(BaseActivityAction, self).__init__(request, group_uid)
self.activity_id = int(activity_id)
def get_activity(self):
activity = Activity.get_unique(id=self.activity_id, group=self.get_group())
if not activity:
message = "searched by activity ID #%s." % self.activity_id
raise EntityNotFoundError(Activity, message)
return activity
def get_activity_access(self):
return ActivityAccess(self.get_activity(), self.current_user)
def update_data(self, data):
data["activity"] = self.get_activity()
data["activity_access"] = self.get_activity_access()
return super(BaseActivityAction, self).update_data(data)
class ViewActivity(BaseActivityAction):
PAGE_URL_NAME = "friday.view_activity"
PAGE_TEMPLATE = "activities/view_activity.html"
AJAX_URL_NAME = "friday.view_activity"
AJAX_TEMPLATE = "activities/common/activity_details.html"
def get_page(self):
data = self.update_data({})
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
class EditActivity(BaseActivityAction):
PAGE_URL_NAME = "friday.edit_activity"
PAGE_TEMPLATE = "activities/edit_activity.html"
def _check_edit_access(self):
if not self.get_activity_access().can_edit():
message = "Current user cannot edit activity #%s." % self.get_activity().id
logging.error(message)
raise BadRequestError(self.request, message)
def get_page(self):
self._check_edit_access()
activity_form = ActivityForm(instance=self.get_activity())
data = {"activity_form": activity_form}
data = self.update_data(data)
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
def post_page(self):
self._check_edit_access()
activity_form = ActivityForm(data=self.request.POST, instance=self.get_activity())
try:
activity = activity_form.update()
message = "Activity #%s has been updated successfully." % activity.id
logging.info(message)
redirect_url = ViewActivity.get_page_url(
group_uid=activity.group.uid,
activity_id=activity.id
)
return HttpResponseRedirect(redirect_url)
except Exception, exc:
message = "Failed to update activity in datastore: %s" % exc
logging.error(message)
logging.exception(exc)
data = {"activity_form": activity_form, "prompt": Prompt(error=message)}
data = self.update_data(data)
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
class DeleteActivity(BaseActivityAction):
PAGE_URL_NAME = "friday.delete_activity"
PAGE_TEMPLATE = "activities/delete_activity.html"
def _check_delete_access(self):
if not self.get_activity_access().can_delete():
message = "Current user cannot delete activity #%s." % self.get_activity().id
logging.error(message)
raise BadRequestError(self.request, message)
def get_page(self):
self._check_delete_access()
data = self.update_data({})
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
def post_page(self):
self._check_delete_access()
try:
activity = self.get_activity()
activity_id = activity.id # Activity instance has no 'id' attribute after deletion.
activity.delete()
message = "Activity #%s has been deleted successfully." % activity_id
logging.info(message)
redirect_url = ViewAllActivities.get_page_url(group_uid=self.get_group().uid)
return HttpResponseRedirect(redirect_url)
except Exception, exc:
message = "Failed to delete activity in datastore: %s" % exc
logging.error(message)
logging.exception(exc)
data = {"prompt": Prompt(error=message)}
data = self.update_data(data)
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
class ViewAttenders(BaseActivityAction):
AJAX_TEMPLATE = "activities/common/attenders.html"
def update_data(self, data):
data["attenders"] = Attender.find_by_activity(self.get_activity())
return super(ViewAttenders, self).update_data(data)
def get_ajax(self):
return {}
def post_ajax(self):
action = self.request.POST.get("action")
if action == "attend":
self._attend()
elif action == "quit":
self._quit()
else:
message = "Unsupported action '%s'." % action
logging.error(message)
raise BadRequestError(self.request, message)
return {}
def _attend(self):
if not self.get_activity_access().can_attend():
message = "Current user cannot attend the activity."
logging.error(message)
raise BadRequestError(self.request, message)
try:
with_friends = int(self.request.POST.get("with_friends", 0))
except (TypeError, ValueError):
with_friends = 0
attender = Attender.create(
activity=self.get_activity(),
user=self.current_user,
with_friends=with_friends
)
attender.save()
def _quit(self):
if not self.get_activity_access().can_quit():
message = "Current user cannot quit the activity."
logging.error(message)
raise BadRequestError(self.request, message)
attender = Attender.get_unique(activity=self.get_activity(), user=self.current_user)
if not attender:
message = "Cannot find attender for current user."
logging.error(message)
raise BadRequestError(self.request, message)
attender.delete()
#---------------------------------------------------------------------------------------------------
def view_all_activities(request, group_uid):
return ViewAllActivities(request, group_uid).process()
def view_upcoming_activities(request, group_uid):
return ViewUpcomingActivities(request, group_uid).process()
def create_activity(request, group_uid):
return CreateActivity(request, group_uid).process()
def view_activity(request, group_uid, activity_id):
return ViewActivity(request, group_uid, activity_id).process()
def edit_activity(request, group_uid, activity_id):
return EditActivity(request, group_uid, activity_id).process()
def delete_activity(request, group_uid, activity_id):
return DeleteActivity(request, group_uid, activity_id).process()
def view_attenders(request, group_uid, activity_id):
return ViewAttenders(request, group_uid, activity_id).process()
# EOF
| zzheng | friday/website/friday/apps/activities/views.py | Python | asf20 | 10,536 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-04-29.
# $Id$
#
import logging
from django.conf import settings
from django.template.loader import render_to_string
from friday.auth import users
from friday.apps.notifications.signals import something_happened
from friday.apps.activities.models import Activity
def _render_message(template_name, data):
template_file = "activities/mails/%s.txt" % template_name
return render_to_string(template_file, data)
def activity_created(activity):
# Do nothing if this group is not associated with a Google Group.
google_group = activity.group.google_group or None
if not google_group:
logging.info("Group is not associated with a Google Group.")
return
# Otherwise, send a mail to the associated Google Group.
_TEMPLATE_NAME = "activity_created"
try:
author = activity.submitter
recipient = "%s@googlegroups.com" % google_group
data = {
"activity": activity,
"http_host": getattr(settings, "MY_HTTP_HOST", None),
}
message = _render_message(_TEMPLATE_NAME, data)
something_happened.send(
sender=Activity.__name__,
subject=None,
message=message,
author=author,
recipients=[recipient]
)
except Exception, exc:
logging.error("Failed to send notification for activity_created: %s" % exc)
logging.exception(exc)
# EOF
| zzheng | friday/website/friday/apps/activities/notifiers.py | Python | asf20 | 1,601 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-02-08.
# $Id$
#
import datetime
from google.appengine.ext import db
from djangomockup import models
from friday.auth import users
from friday.common.dbutils import filter_key
class Group(models.Model):
_RESERVED_KEYS = ("create",)
uid = db.StringProperty(required=True)
name = db.StringProperty(required=True)
slogan = db.StringProperty()
description = db.TextProperty()
website = db.LinkProperty()
google_group = db.StringProperty()
background_url = db.LinkProperty()
logo_icon_url = db.LinkProperty()
creator = db.ReferenceProperty(users.User, required=True, collection_name="created_groups")
create_date = db.DateProperty(required=True)
owner = db.ReferenceProperty(users.User, required=True, collection_name="owned_groups")
own_date = db.DateProperty(required=True)
schema_version = db.IntegerProperty(required=True, default=1)
def __unicode__(self):
return unicode(self.name)
@property
def population(self):
return Member.find_by_group(group=self, is_approved=True).count()
@classmethod
def _make_pk(cls, uid):
return filter_key(uid, reserved=cls._RESERVED_KEYS)
@classmethod
def get_unique(cls, uid):
pk = cls._make_pk(uid)
try:
instance = cls.objects.get(pk=pk)
except cls.DoesNotExist:
instance = None
return instance
@classmethod
def create(cls, uid, creator, **kwargs):
pk = cls._make_pk(uid)
if kwargs.get("create_date"):
create_date = kwargs["create_date"]
del kwargs["create_date"]
else:
create_date = datetime.date.today()
return cls(
key_name=pk,
uid=pk,
creator=creator,
create_date=create_date,
owner=creator,
own_date=create_date,
**kwargs
)
@classmethod
def find_all(cls, **kwargs):
query = cls.objects.order_by(kwargs.get("order_by") or "-create_date")
if kwargs.get("limit"):
query.set_limit(kwargs["limit"])
return query
class Member(models.Model):
ADMINISTRATOR = "administrator"
MODERATOR = "moderator"
MEMBER = "member"
group = db.ReferenceProperty(reference_class=Group, required=True)
user = db.ReferenceProperty(users.User, required=True)
role = db.StringProperty(required=True, default=MEMBER)
join_date = db.DateProperty(required=True)
request_message = db.TextProperty()
is_approved = db.BooleanProperty(required=True, default=False)
is_emeritus = db.BooleanProperty(required=True, default=False)
schema_version = db.IntegerProperty(required=True, default=1)
@property
def username(self):
return self.user.username
@property
def email(self):
return self.user.email
def __unicode__(self):
return unicode(self.user)
@classmethod
def _make_pk(cls, group, user):
return "%s/%s" % (group.uid, user.email.lower())
@classmethod
def create(cls, group, user, **kwargs):
pk = cls._make_pk(group, user)
if "join_date" not in kwargs:
kwargs["join_date"] = datetime.date.today()
return cls(key_name=pk, group=group, user=user, **kwargs)
@classmethod
def get_unique(cls, group, user):
pk = cls._make_pk(group, user)
try:
instance = cls.objects.get(pk=pk)
except cls.DoesNotExist:
instance = None
return instance
@classmethod
def find_by_group(cls, group, is_approved=True, **kwargs):
query = cls.objects.filter(group=group, is_approved=is_approved)
query = query.order_by(kwargs.get("order_by") or "-join_date")
if kwargs.get("cursor"):
query.with_cursor(kwargs["cursor"])
if kwargs.get("limit"):
query.set_limit(kwargs["limit"])
return query
@classmethod
def find_by_user(cls, user, **kwargs):
query = cls.objects.filter(user=user)
if kwargs.get("order_by"):
query = query.order_by(kwargs.get("order_by"))
return query
# EOF
| zzheng | friday/website/friday/apps/groups/models.py | Python | asf20 | 4,455 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-02-08.
# $Id$
#
from friday.auth import users
from friday.apps.groups.models import Group, Member
class GroupAccess(object):
def __init__(self, group, user):
self._group = group
self._user = user
if user:
self._member = Member.get_unique(group=group, user=user)
else:
self._member = None
@property
def member(self):
return self._member
def can_administrate(self):
if users.is_webmaster(self._user):
return True
if self._user and self._user == self._group.owner:
return True
if self._member and self._member.is_approved:
return self._member.role == Member.ADMINISTRATOR
return False
def can_moderate(self):
if self.can_administrate():
return True
if self._member and self._member.is_approved:
return self._member.role == Member.MODERATOR
return False
def can_contribute(self):
if self.can_moderate():
return True
return self._member and self._member.is_approved
def can_join(self):
return self._user and self._member is None
def can_quit(self):
return self._user and self._member is not None
# EOF
| zzheng | friday/website/friday/apps/groups/access.py | Python | asf20 | 1,449 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-02-08.
# $Id$
#
from django import forms
from friday.common.errors import ProgrammingError, InvalidFormError
from friday.apps.groups.models import Group, Member
class GroupForm(forms.Form):
uid = forms.CharField(max_length=32, required=True)
name = forms.CharField(max_length=128, required=True)
slogan = forms.CharField(max_length=255, required=False)
description = forms.CharField(required=False, widget=forms.Textarea)
website = forms.URLField(required=False)
google_group = forms.CharField(required=False)
def __init__(self, data=None, instance=None):
self._instance = instance
if instance:
initial = {
"uid": instance.uid,
"name": instance.name,
"slogan": instance.slogan,
"description": instance.description,
"website": instance.website,
"google_group": instance.google_group,
}
else:
initial = None
super(GroupForm, self).__init__(data=data, initial=initial)
@property
def instance(self):
return self._instance
def clean_website(self):
return self.cleaned_data["website"] or None
def create(self, creator):
if self._instance is not None:
message = "Failed to create group: this form is bound to an existing group."
raise ProgrammingError(message)
if not self.is_valid():
raise InvalidFormError(self.errors)
instance = Group.create(creator=creator, **self.cleaned_data)
instance.save()
return instance
def update(self):
if self._instance is None:
message = "Failed to update group: this form is not bound to a group."
raise ProgrammingError(message)
if not self.is_valid():
raise InvalidFormError(self.errors)
if self._instance.uid != self.cleaned_data["uid"]:
message = "Group uid is read-only, and cannot be updated."
raise ProgrammingError(message)
for name, value in self.cleaned_data.items():
if name != "uid":
setattr(self._instance, name, value)
self._instance.save()
return self._instance
class PrettifyGroupForm(forms.Form):
background_url = forms.URLField(required=False)
logo_icon_url = forms.URLField(required=False)
def __init__(self, data=None, instance=None):
if not instance:
message = "Failed to create prettify group form: this form must be bound to a group."
raise ProgrammingError(message)
self._instance = instance
initial = {
"background_url": instance.background_url,
"logo_icon_url": instance.logo_icon_url,
}
super(PrettifyGroupForm, self).__init__(data=data, initial=initial)
@property
def instance(self):
return self._instance
def clean_background_url(self):
return self.cleaned_data["background_url"] or None
def clean_logo_icon_url(self):
return self.cleaned_data["logo_icon_url"] or None
def update(self):
if not self.is_valid():
raise InvalidFormError(self.errors)
for name, value in self.cleaned_data.items():
setattr(self._instance, name, value)
self._instance.save()
return self._instance
class JoinGroupForm(forms.Form):
request_message = forms.CharField(required=False, widget=forms.Textarea)
def create(self, user, group):
if not self.is_valid():
raise InvalidFormError(self.errors)
instance = Member.create(user=user, group=group, **self.cleaned_data)
instance.save()
return instance
class ReviewMemberForm(forms.Form):
_APPROVE = "approve"
_REJECT = "reject"
_DECIDE_LATER = "decide_later"
_REVIEW_CHOICES = (
(_APPROVE, "Approve the request and add the user to this group."),
(_REJECT, "Reject the request and remove the user from this group."),
(_DECIDE_LATER, "Decide later."),
)
review = forms.ChoiceField(choices=_REVIEW_CHOICES, required=True, widget=forms.RadioSelect)
def __init__(self, data=None, instance=None):
if not instance:
message = "Failed to create review member form: this form must be bound to a member."
raise ProgrammingError(message)
elif instance.is_approved:
message = "Failed to create review member form: member is already approved."
raise ProgrammingError(message)
self._instance = instance
initial = {"review": ReviewMemberForm._APPROVE}
super(ReviewMemberForm, self).__init__(data=data, initial=initial)
@property
def instance(self):
return self._instance
def update(self):
if not self.is_valid():
raise InvalidFormError(self.errors)
review = self.cleaned_data["review"]
if review == ReviewMemberForm._APPROVE:
self._instance.is_approved = True
self._instance.save()
elif review == ReviewMemberForm._REJECT:
self._instance.delete()
else:
pass
return self._instance
class MemberForm(forms.Form):
_ROLE_CHOICES = (
(Member.ADMINISTRATOR, "Administrator - administrator can change group settings"),
(Member.MODERATOR, "Moderator - moderator can approve pending members"),
(Member.MEMBER, "Member - member can view the group contents"),
)
role = forms.ChoiceField(choices=_ROLE_CHOICES, required=True, widget=forms.RadioSelect)
remove_member = forms.BooleanField(required=False)
def __init__(self, data=None, instance=None):
self._instance = instance
initial = {"remove_member": False}
if instance:
initial["role"] = instance.role
super(MemberForm, self).__init__(data=data, initial=initial)
@property
def instance(self):
return self._instance
def update(self):
if self._instance is None:
message = "Failed to update member: this form is not bound to a member."
raise ProgrammingError(message)
if not self.is_valid():
raise InvalidFormError(self.errors)
if not self.cleaned_data["remove_member"]:
self._instance.role = self.cleaned_data["role"]
self._instance.save()
else:
self._instance.delete()
return self._instance
# EOF
| zzheng | friday/website/friday/apps/groups/forms.py | Python | asf20 | 6,840 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-02-08.
# $Id$
#
from django.conf.urls.defaults import *
from friday.apps.groups.views import *
urlpatterns = patterns("",
url(
r"^$",
groups_home,
name="friday.groups_home"
),
url(
r"^all/$",
view_all_groups,
name="friday.view_all_groups"
),
url(
r"^create/$",
create_group,
name="friday.create_group"
),
url(
r"^(?P<group_uid>\w+)/$",
view_group,
name="friday.view_group"
),
url(
r"^(?P<group_uid>\w+)/edit/$",
edit_group,
name="friday.edit_group"
),
url(
r"^(?P<group_uid>\w+)/prettify/$",
prettify_group,
name="friday.prettify_group"
),
url(
r"^(?P<group_uid>\w+)/join/$",
join_group,
name="friday.join_group"
),
url(
r"^(?P<group_uid>\w+)/members/$",
view_members,
name="friday.view_members"
),
url(
r"^(?P<group_uid>\w+)/review/(?P<username>[\w\.\-@]+)/$",
review_member,
name="friday.review_member"
),
url(
r"^(?P<group_uid>\w+)/member/(?P<username>[\w\.\-@]+)/$",
edit_member,
name="friday.edit_member"
),
)
# EOF
| zzheng | friday/website/friday/apps/groups/urls.py | Python | asf20 | 1,443 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-02-08.
# $Id$
#
| zzheng | friday/website/friday/apps/groups/__init__.py | Python | asf20 | 154 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-02-08.
# $Id$
#
import logging
from django.http import HttpRequest, HttpResponse, HttpResponseRedirect
from django.template import RequestContext
from django.shortcuts import render_to_response
from friday.auth import users
from friday.common.actions import Action
from friday.common.errors import BadRequestError, EntityNotFoundError
from friday.common.prompt import Prompt
from friday.apps.groups.models import Group, Member
from friday.apps.groups.access import GroupAccess
from friday.apps.groups.forms import GroupForm, PrettifyGroupForm, JoinGroupForm, \
ReviewMemberForm, MemberForm
class ViewAllGroups(Action):
PAGE_URL_NAME = "friday.view_all_groups"
PAGE_TEMPLATE = "groups/view_all_groups.html"
def get_page(self):
data = self.update_data({"groups": Group.find_all()})
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
class CreateGroup(Action):
PAGE_URL_NAME = "friday.create_group"
PAGE_TEMPLATE = "groups/create_group.html"
def _check_create_access(self):
if not users.is_webmaster(self.current_user):
message = "Only webmaster can create new groups."
logging.error(message)
raise BadRequestError(self.request, message)
def get_page(self):
self._check_create_access()
data = {"group_form": GroupForm()}
data = self.update_data(data)
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
def post_page(self):
self._check_create_access()
group_form = GroupForm(data=self.request.POST)
try:
group = group_form.create(creator=self.current_user)
message = "Group %s has been created successfully." % group.uid
logging.info(message)
redirect_url = ViewGroup.get_page_url(group_uid=group.uid)
return HttpResponseRedirect(redirect_url)
except Exception, exc:
message = "Failed to create group in datastore: %s" % exc
logging.error(message)
logging.exception(exc)
data = {"group_form": group_form, "prompt": Prompt(error=message)}
data = self.update_data(data)
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
class BaseGroupAction(Action):
def __init__(self, request, group_uid):
super(BaseGroupAction, self).__init__(request)
self.group_uid = group_uid
def get_group(self):
group = Group.get_unique(uid=self.group_uid)
if not group:
message = "searched by group uid %s." % self.group_uid
raise EntityNotFoundError(Group, message)
return group
def get_group_access(self):
return GroupAccess(self.get_group(), self.current_user)
def update_data(self, data):
data["group"] = self.get_group()
data["group_access"] = self.get_group_access()
return super(BaseGroupAction, self).update_data(data)
class ViewGroup(BaseGroupAction):
PAGE_URL_NAME = "friday.view_group"
PAGE_TEMPLATE = "groups/view_group.html"
def get_page(self):
pending_members = Member.find_by_group(
group=self.get_group(),
is_approved=False,
order_by="-join_date"
)
new_members = Member.find_by_group(
group=self.get_group(),
is_approved=True,
order_by="-join_date",
limit=7
)
data = {"pending_members": pending_members, "new_members": new_members}
data = self.update_data(data)
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
class EditGroup(BaseGroupAction):
PAGE_URL_NAME = "friday.edit_group"
PAGE_TEMPLATE = "groups/edit_group.html"
def _check_edit_access(self):
if not self.get_group_access().can_administrate():
message = "Current user cannot edit group %s." % self.get_group().uid
logging.error(message)
raise BadRequestError(self.request, message)
def get_page(self):
self._check_edit_access()
group_form = GroupForm(instance=self.get_group())
data = {"group_form": group_form}
data = self.update_data(data)
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
def post_page(self):
self._check_edit_access()
group_form = GroupForm(data=self.request.POST, instance=self.get_group())
try:
group = group_form.update()
message = "Group %s has been updated successfully." % group.uid
logging.info(message)
redirect_url = ViewGroup.get_page_url(group_uid=group.uid)
return HttpResponseRedirect(redirect_url)
except Exception, exc:
message = "Failed to update group in datastore: %s" % exc
logging.error(message)
logging.exception(exc)
data = {"group_form": group_form, "prompt": Prompt(error=message)}
data = self.update_data(data)
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
class PrettifyGroup(BaseGroupAction):
PAGE_URL_NAME = "friday.prettify_group"
PAGE_TEMPLATE = "groups/prettify_group.html"
def _check_edit_access(self):
if not self.get_group_access().can_administrate():
message = "Current user cannot prettify group %s." % self.get_group().uid
logging.error(message)
raise BadRequestError(self.request, message)
def get_page(self):
self._check_edit_access()
prettify_group_form = PrettifyGroupForm(instance=self.get_group())
data = {"prettify_group_form": prettify_group_form}
data = self.update_data(data)
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
def post_page(self):
self._check_edit_access()
prettify_group_form = PrettifyGroupForm(data=self.request.POST, instance=self.get_group())
try:
group = prettify_group_form.update()
message = "Group %s has been updated successfully." % group.uid
logging.info(message)
redirect_url = ViewGroup.get_page_url(group_uid=group.uid)
return HttpResponseRedirect(redirect_url)
except Exception, exc:
message = "Failed to update group in datastore: %s" % exc
logging.error(message)
logging.exception(exc)
data = {"prettify_group_form": prettify_group_form, "prompt": Prompt(error=message)}
data = self.update_data(data)
return render_to_response(self.PAGE_TEMPLATE, data, RequestContext(self.request))
class JoinGroup(BaseGroupAction):
PAGE_URL_NAME = "friday.join_group"
PAGE_TEMPLATE = "groups/join_group.html"
def _check_join_access(self):
if not self.get_group_access().can_join():
message = "Current user cannot join group %s." % self.get_group().uid
logging.error(message)
raise BadRequestError(self.request, message)
def get_page(self):
self._check_join_access()
data = {"join_group_form": JoinGroupForm()}
data = self.update_data(data)
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
def post_page(self):
self._check_join_access()
join_group_form = JoinGroupForm(data=self.request.POST)
try:
member = join_group_form.create(user=self.current_user, group=self.get_group())
message = "Member '%s' has been created successfully." % member.pk
logging.info(message)
redirect_url = ViewGroup.get_page_url(group_uid=self.get_group().uid)
return HttpResponseRedirect(redirect_url)
except Exception, exc:
message = "Failed to create member in datastore: %s" % exc
logging.error(message)
logging.exception(exc)
data = {"join_group_form": join_group_form, "prompt": Prompt(error=message)}
data = self.update_data(data)
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
class ViewMembers(BaseGroupAction):
PAGE_URL_NAME = "friday.view_members"
PAGE_TEMPLATE = "groups/view_members.html"
def get_page(self):
order_by = self.request.GET.get("order_by") or "-join_date"
cursor = self.request.GET.get("cursor") or None
pending_members = Member.find_by_group(
group=self.get_group(),
is_approved=False,
order_by=order_by
)
approved_members = Member.find_by_group(
group=self.get_group(),
is_approved=True,
order_by=order_by,
cursor=cursor,
limit=20
)
data = {
"pending_members": pending_members,
"approved_members": approved_members,
"ordered_by": order_by,
}
data = self.update_data(data)
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
class BaseMemberAction(BaseGroupAction):
def __init__(self, request, group_uid, username):
super(BaseMemberAction, self).__init__(request, group_uid)
self._username = username
self._user = users.get_user(username, create=False)
def get_user(self):
if not self._user:
message = "searched by username %s." % self._username
raise EntityNotFoundError(users.User, message)
return self._user
def get_member(self):
member = Member.get_unique(group=self.get_group(), user=self.get_user())
if not member:
message = "searched by user %s." % self.get_user().username
raise EntityNotFoundError(Member, message)
return member
def update_data(self, data):
data["member"] = self.get_member()
return super(BaseMemberAction, self).update_data(data)
class ReviewMember(BaseMemberAction):
PAGE_URL_NAME = "friday.review_member"
PAGE_TEMPLATE = "groups/review_member.html"
def _check_review_access(self):
if self.get_member().is_approved:
message = "Member '%s' does not need to be reviewed." % self.get_member().username
logging.error(message)
raise BadRequestError(self.request, message)
if not self.get_group_access().can_moderate():
message = "Current user cannot review member '%s'." % self.get_member().username
logging.error(message)
raise BadRequestError(self.request, message)
def get_page(self):
self._check_review_access()
review_member_form = ReviewMemberForm(instance=self.get_member())
data = {"review_member_form": review_member_form}
data = self.update_data(data)
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
def post_page(self):
self._check_review_access()
review_member_form = ReviewMemberForm(data=self.request.POST, instance=self.get_member())
try:
member = review_member_form.update()
message = "Member %s has been updated successfully." % member.username
logging.info(message)
redirect_url = ViewMembers.get_page_url(group_uid=self.get_group().uid)
return HttpResponseRedirect(redirect_url)
except Exception, exc:
message = "Failed to update member in datastore: %s" % exc
logging.error(message)
logging.exception(exc)
data = {"review_member_form": review_member_form, "prompt": Prompt(error=message)}
data = self.update_data(data)
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
class EditMember(BaseMemberAction):
PAGE_URL_NAME = "friday.edit_member"
PAGE_TEMPLATE = "groups/edit_member.html"
def _check_edit_access(self):
if not self.get_group_access().can_administrate():
message = "Current user cannot edit member '%s'." % self.get_member().username
logging.error(message)
raise BadRequestError(self.request, message)
def get_page(self):
self._check_edit_access()
member_form = MemberForm(instance=self.get_member())
data = {"member_form": member_form}
data = self.update_data(data)
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
def post_page(self):
self._check_edit_access()
member_form = MemberForm(data=self.request.POST, instance=self.get_member())
try:
member = member_form.update()
message = "Member '%s' has been updated successfully." % member.username
logging.info(message)
redirect_url = ViewMembers.get_page_url(group_uid=self.get_group().uid)
return HttpResponseRedirect(redirect_url)
except Exception, exc:
message = "Failed to update member in datastore: %s" % exc
logging.error(message)
logging.exception(exc)
data = {"member_form": member_form, "prompt": Prompt(error=message)}
data = self.update_data(data)
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
#---------------------------------------------------------------------------------------------------
def groups_home(request):
redirect_url = ViewAllGroups.get_page_url()
return HttpResponseRedirect(redirect_url)
def view_all_groups(request):
return ViewAllGroups(request).process()
def create_group(request):
return CreateGroup(request).process()
def view_group(request, group_uid):
return ViewGroup(request, group_uid).process()
def edit_group(request, group_uid):
return EditGroup(request, group_uid).process()
def prettify_group(request, group_uid):
return PrettifyGroup(request, group_uid).process()
def join_group(request, group_uid):
return JoinGroup(request, group_uid).process()
def view_members(request, group_uid):
return ViewMembers(request, group_uid).process()
def review_member(request, group_uid, username):
return ReviewMember(request, group_uid, username).process()
def edit_member(request, group_uid, username):
return EditMember(request, group_uid, username).process()
# EOF
| zzheng | friday/website/friday/apps/groups/views.py | Python | asf20 | 15,174 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-05-11.
# $Id$
#
import logging
from google.appengine.ext import db
from djangomockup import models
from friday.auth import users
from friday.common.dbutils import filter_key
from friday.apps.groups.models import Group
class Inductee(models.Model):
group = db.ReferenceProperty(Group, required=True)
uid = db.StringProperty(required=True)
name = db.StringProperty(required=True)
aka = db.StringProperty()
user = db.ReferenceProperty(users.User)
summary = db.StringProperty()
biography = db.TextProperty(required=True)
photo_type = db.StringProperty()
photo_data = db.BlobProperty()
induct_date = db.DateProperty(required=True, auto_now_add=True)
schema_version = db.IntegerProperty(required=True, default=1)
def __unicode__(self):
return unicode(self.name)
@classmethod
def _make_uid(cls, uid):
return filter_key(uid)
@classmethod
def _make_pk(cls, group, uid):
return "%s/%s" % (group.uid, cls._make_uid(uid))
@classmethod
def create(cls, group, uid, **kwargs):
uid = cls._make_uid(uid)
pk = cls._make_pk(group, uid)
return cls(key_name=pk, group=group, uid=uid, **kwargs)
@classmethod
def get_unique(cls, group, uid):
pk = cls._make_pk(group, uid)
try:
instance = cls.objects.get(pk=pk)
except cls.DoesNotExist:
instance = None
return instance
@classmethod
def find_by_group(cls, group, **kwargs):
query = cls.objects.filter(group=group)
query = query.order_by(kwargs.get("order_by") or "-induct_date")
if kwargs.get("limit"):
query.set_limit(kwargs["limit"])
return query
# EOF
| zzheng | friday/website/friday/apps/halloffame/models.py | Python | asf20 | 1,929 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-05-11.
# $Id$
#
from django import forms
from friday.auth import users
from friday.common.errors import ProgrammingError, InvalidFormError
from friday.apps.halloffame.models import Inductee
class InducteeForm(forms.Form):
uid = forms.CharField(max_length=32, required=True)
name = forms.CharField(max_length=64, required=True)
aka = forms.CharField(max_length=64, required=False)
user = forms.CharField(max_length=64, required=True)
summary = forms.CharField(max_length=128, required=True)
biography = forms.CharField(required=True, widget=forms.Textarea)
def __init__(self, data=None, instance=None):
self._instance = instance
if instance:
initial = {
"uid": instance.uid,
"name": instance.name,
"aka": instance.aka,
"user": instance.user.email,
"summary": instance.summary,
"biography": instance.biography,
}
else:
initial = None
super(InducteeForm, self).__init__(data=data, initial=initial)
@property
def instance(self):
return self._instance
def clean_user(self):
username_or_email = self.cleaned_data["user"]
user = users.get_user(username_or_email, create=False)
if user is None:
message = "User %s cannot be found." % username_or_email
raise forms.ValidationError(message)
return user
def create(self, group):
if self._instance is not None:
message = "Failed to create inductee: this form is bound to an existing instance."
raise ProgrammingError(message)
if not self.is_valid():
raise InvalidFormError(self.errors)
instance = Inductee.create(group=group, **self.cleaned_data)
instance.save()
return instance
def update(self):
if self._instance is None:
message = "Failed to update inductee: this form is not bound to an instance."
raise ProgrammingError(message)
if not self.is_valid():
raise InvalidFormError(self.errors)
if self._instance.uid != self.cleaned_data["uid"]:
message = "Inductee uid is read-only, and cannot be updated."
raise ProgrammingError(message)
for name, value in self.cleaned_data.items():
if name != "uid":
setattr(self._instance, name, value)
self._instance.save()
return self._instance
class InducteePhotoForm(forms.Form):
photo = forms.FileField(required=False)
delete_photo = forms.BooleanField(required=False, initial=False)
def update(self, inductee):
if not self.is_valid():
raise InvalidFormError(self.errors)
if self.cleaned_data["delete_photo"]:
inductee.photo_type = None
inductee.photo_data = None
photo = self.cleaned_data["photo"]
if photo:
inductee.photo_type = photo.content_type
inductee.photo_data = photo.read()
inductee.save()
return inductee
# EOF
| zzheng | friday/website/friday/apps/halloffame/forms.py | Python | asf20 | 3,351 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-05-11.
# $Id$
#
from django.conf.urls.defaults import *
from friday.apps.halloffame.views import *
urlpatterns = patterns("",
url(
r"^$",
view_hall_of_fame,
name="friday.view_hall_of_fame"
),
url(
r"^add/$",
add_inductee,
name="friday.add_inductee"
),
url(
r"^(?P<inductee_uid>\w+)/$",
view_inductee,
name="friday.view_inductee"
),
url(
r"^(?P<inductee_uid>\w+)/edit/$",
edit_inductee,
name="friday.edit_inductee"
),
url(
r"^(?P<inductee_uid>\w+)/change_photo/$",
change_inductee_photo,
name="friday.change_inductee_photo"
),
url(
r"^(?P<inductee_uid>\w+)/photo/$",
view_inductee_photo,
name="friday.view_inductee_photo"
),
)
# EOF
| zzheng | friday/website/friday/apps/halloffame/urls.py | Python | asf20 | 1,003 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-05-11.
# $Id$
#
| zzheng | friday/website/friday/apps/halloffame/__init__.py | Python | asf20 | 150 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-05-11.
# $Id$
#
import logging
from django.http import HttpRequest, HttpResponse, HttpResponseRedirect
from django.template import RequestContext
from django.shortcuts import render_to_response
from friday.auth import users
from friday.common.errors import BadRequestError, EntityNotFoundError
from friday.common.prompt import Prompt
from friday.apps.groups.models import Group
from friday.apps.groups.views import BaseGroupAction
from friday.apps.halloffame.models import Inductee
from friday.apps.halloffame.forms import InducteeForm, InducteePhotoForm
class ViewHallOfFame(BaseGroupAction):
PAGE_URL_NAME = "friday.view_hall_of_fame"
PAGE_TEMPLATE = "halloffame/home.html"
def get_page(self):
data = {"inductees": Inductee.find_by_group(group=self.get_group())}
data = self.update_data(data)
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
class AddInductee(BaseGroupAction):
PAGE_URL_NAME = "friday.add_inductee"
PAGE_TEMPLATE = "halloffame/add_inductee.html"
def _check_create_access(self):
if not users.is_webmaster(self.current_user):
message = "Current user cannot add an inductee."
raise BadRequestError(self.request, message)
def get_page(self):
self._check_create_access()
data = {"inductee_form": InducteeForm()}
data = self.update_data(data)
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
def post_page(self):
self._check_create_access()
inductee_form = InducteeForm(data=self.request.POST)
try:
inductee = inductee_form.create(group=self.get_group())
message = "Inductee %s has been created successfully." % inductee.uid
logging.info(message)
redirect_url = ViewInductee.get_page_url(
group_uid=inductee.group.uid,
inductee_uid=inductee.uid
)
return HttpResponseRedirect(redirect_url)
except Exception, exc:
message = "Failed to create inductee in datastore: %s" % exc
logging.error(message)
logging.exception(exc)
data = {"inductee_form": inductee_form, "prompt": Prompt(error=message)}
data = self.update_data(data)
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
class BaseInducteeAction(BaseGroupAction):
def __init__(self, request, group_uid, inductee_uid):
super(BaseInducteeAction, self).__init__(request, group_uid)
self.inductee_uid = inductee_uid
def get_inductee(self):
inductee = Inductee.get_unique(group=self.get_group(), uid=self.inductee_uid)
if not inductee:
message = "searched by inductee uid '%s'." % self.inductee_uid
raise EntityNotFoundError(Inductee, message)
return inductee
def update_data(self, data):
data["inductee"] = self.get_inductee()
return super(BaseInducteeAction, self).update_data(data)
class ViewInductee(BaseInducteeAction):
PAGE_URL_NAME = "friday.view_inductee"
PAGE_TEMPLATE = "halloffame/view_inductee.html"
def get_page(self):
data = self.update_data({})
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
class EditInductee(BaseInducteeAction):
PAGE_URL_NAME = "friday.edit_inductee"
PAGE_TEMPLATE = "halloffame/edit_inductee.html"
def _check_edit_access(self):
if not users.is_webmaster(self.current_user):
message = "Current user cannot edit inductee."
raise BadRequestError(self.request, message)
def get_page(self):
self._check_edit_access()
data = {"inductee_form": InducteeForm(instance=self.get_inductee())}
data = self.update_data(data)
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
def post_page(self):
self._check_edit_access()
inductee_form = InducteeForm(data=self.request.POST, instance=self.get_inductee())
try:
inductee = inductee_form.update()
message = "Inductee %s has been updated successfully." % inductee.uid
logging.info(message)
redirect_url = ViewInductee.get_page_url(
group_uid=inductee.group.uid,
inductee_uid=inductee.uid
)
return HttpResponseRedirect(redirect_url)
except Exception, exc:
message = "Failed to update inductee in datastore: %s" % exc
logging.error(message)
logging.exception(exc)
data = {"inductee_form": inductee_form, "prompt": Prompt(error=message)}
data = self.update_data(data)
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
class ChangeInducteePhoto(BaseInducteeAction):
PAGE_URL_NAME = "friday.change_inductee_photo"
PAGE_TEMPLATE = "halloffame/change_inductee_photo.html"
def _check_edit_access(self):
if not users.is_webmaster(self.current_user):
message = "Current user cannot change photo of inductee."
raise BadRequestError(self.request, message)
def get_page(self):
self._check_edit_access()
data = {"inductee_photo_form": InducteePhotoForm()}
data = self.update_data(data)
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
def post_page(self):
self._check_edit_access()
inductee_photo_form = InducteePhotoForm(data=self.request.POST, files=self.request.FILES)
try:
inductee = inductee_photo_form.update(inductee=self.get_inductee())
message = "Photo of inductee %s has been created successfully." % inductee.uid
logging.info(message)
redirect_url = ViewInductee.get_page_url(
group_uid=self.group_uid,
inductee_uid=inductee.uid
)
return HttpResponseRedirect(redirect_url)
except Exception, exc:
message = "Failed to update photo of inductee in datastore: %s" % exc
logging.error(message)
logging.exception(exc)
data = {"inductee_photo_form": inductee_photo_form, "prompt": Prompt(error=message)}
data = self.update_data(data)
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
class ViewInducteePhoto(BaseInducteeAction):
PAGE_URL_NAME = "friday.view_inductee_photo"
def get_page(self):
inductee = self.get_inductee()
if not inductee.photo_type or not inductee.photo_data:
message = "Inductee %s does not have a photo." % inductee.uid
raise BadRequestError(self.request, message)
return HttpResponse(inductee.photo_data, mimetype=inductee.photo_type)
#---------------------------------------------------------------------------------------------------
def view_hall_of_fame(request, group_uid):
return ViewHallOfFame(request, group_uid).process()
def add_inductee(request, group_uid):
return AddInductee(request, group_uid).process()
def view_inductee(request, group_uid, inductee_uid):
return ViewInductee(request, group_uid, inductee_uid).process()
def edit_inductee(request, group_uid, inductee_uid):
return EditInductee(request, group_uid, inductee_uid).process()
def change_inductee_photo(request, group_uid, inductee_uid):
return ChangeInducteePhoto(request, group_uid, inductee_uid).process()
def view_inductee_photo(request, group_uid, inductee_uid):
return ViewInducteePhoto(request, group_uid, inductee_uid).process()
# EOF
| zzheng | friday/website/friday/apps/halloffame/views.py | Python | asf20 | 8,176 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-05-03.
# $Id$
#
from friday.apps.migration.models_v1 import *
def get_all_models():
return (
Activity,
Attender,
Comment,
Group,
Member,
Notification,
Profile,
Resto,
Tag,
)
def get_model(model_name):
for model_class in get_all_models():
if model_class.__name__ == model_name:
return model_class
return None
# EOF
| zzheng | friday/website/friday/apps/migration/models.py | Python | asf20 | 589 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-05-03.
# $Id$
#
from django.conf.urls.defaults import *
from friday.apps.migration.views import *
urlpatterns = patterns("",
url(
r"^$",
migrate_model,
name="friday.migrate_model"
),
)
# EOF
| zzheng | friday/website/friday/apps/migration/urls.py | Python | asf20 | 380 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-05-03.
# $Id$
#
import datetime
import logging
from django.conf import settings
from google.appengine.ext import db
class MigrationModel(db.Expando):
to_schema_version = None
schema_version = db.IntegerProperty(required=True)
def pk(self):
if self.is_saved():
return self.key().id() or self.key().name()
else:
raise AttributeError("%s object has no attribute 'pk'" % self.__class__.__name__)
def save(self):
super(MigrationModel, self).put()
def upgrade(self):
raise NotImplementedError("sub-class should implement upgrade()")
@classmethod
def find_old(cls, limit):
gql = "WHERE schema_version = :schema_version ORDER BY __key__ LIMIT %d" % limit
schema_version = cls.to_schema_version - 1
old_instances = cls.gql(gql, schema_version=schema_version)
return old_instances
@classmethod
def has_old(cls):
gql = "WHERE schema_version < :to_schema_version LIMIT 1"
old_instances = cls.gql(gql, to_schema_version=cls.to_schema_version)
return old_instances.count() > 0
@classmethod
def migrate(cls, limit=None):
succeeded, failed = 0, 0
limit = limit or getattr(settings, "MY_MIGRATION_NUM_PER_REQUEST", 20)
old_instances = cls.find_old(limit)
for instance in old_instances:
try:
instance.upgrade()
instance.schema_version = cls.to_schema_version
instance.save()
succeeded += 1
except Exception, exc:
logging.error("Failed to migrate %s %s: %s" % (cls.__name__, instance.pk, exc))
logging.exception(exc)
failed += 1
return succeeded, failed
# EOF
| zzheng | friday/website/friday/apps/migration/model_base.py | Python | asf20 | 1,979 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-05-03.
# $Id$
#
| zzheng | friday/website/friday/apps/migration/__init__.py | Python | asf20 | 150 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-05-03.
# $Id$
#
import logging
from django.http import HttpRequest, HttpResponse, HttpResponseRedirect
from django.template import RequestContext
from django.shortcuts import render_to_response
from friday.auth import users
from friday.common.actions import Action
from friday.common.errors import BadRequestError
from friday.apps.migration.models import get_to_schema_version, get_all_models, get_model
class MigrateModel(Action):
PAGE_URL_NAME = "friday.migrate_model"
PAGE_TEMPLATE = "migration/migrate_model.html"
AJAX_URL_NAME = "friday.migrate_model"
AJAX_TEMPLATE = "migration/common/migrating.html"
def _check_migrate_access(self):
if not users.is_webmaster(self.current_user):
message = "Current user cannot migrate model."
raise BadRequestError(self.request, message)
def get_page(self):
all_models = {}
for model_class in get_all_models():
all_models[model_class.__name__] = model_class.has_old()
data = {
"to_schema_version": get_to_schema_version(),
"all_models": all_models,
}
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
def post_ajax(self):
self._check_migrate_access()
model_name = self.request.POST.get("model_name")
model_class = get_model(model_name)
if not model_class:
message = "Failed to find model class by name '%s'." % model_name
raise BadRequestError(self.request, message)
succeeded, failed = model_class.migrate()
logging.info("Migrating %s: %s succeeded, %s failed." % (model_name, succeeded, failed))
is_complete = not model_class.has_old()
data = {
"model_name": model_name,
"succeeded": succeeded,
"failed": failed,
"is_complete": is_complete,
}
return data
#---------------------------------------------------------------------------------------------------
def migrate_model(request):
return MigrateModel(request).process()
# EOF
| zzheng | friday/website/friday/apps/migration/views.py | Python | asf20 | 2,314 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-05-03.
# $Id$
#
import datetime
import logging
from google.appengine.ext import db
from friday.apps.migration.model_base import MigrationModel
class _Model_v1(MigrationModel):
to_schema_version = 1
def upgrade(self):
pass
# --------------------------------------------------------------------------------------------------
class Activity(_Model_v1): pass
class Attender(_Model_v1): pass
class Comment(_Model_v1): pass
class Group(_Model_v1): pass
class Member(_Model_v1): pass
class Notification(_Model_v1): pass
class Profile(_Model_v1): pass
class Resto(_Model_v1): pass
class Tag(_Model_v1): pass
def get_to_schema_version():
return _Model_v1.to_schema_version
# EOF
| zzheng | friday/website/friday/apps/migration/models_v1.py | Python | asf20 | 891 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-05-11.
# $Id$
#
import logging
from google.appengine.ext import db
from djangomockup import models
from djangomockup.models.signals import pre_delete
from friday.auth import users
class Fan(models.Model):
MIN_RATING = 1
MAX_RATING = 5
ref_type = db.StringProperty(required=True)
ref_pk = db.StringProperty(required=True)
user = db.ReferenceProperty(users.User, required=True)
rating = db.IntegerProperty(required=True)
rate_date = db.DateTimeProperty(auto_now_add=True)
schema_version = db.IntegerProperty(required=True, default=1)
@classmethod
def _make_pk(cls, ref_type, ref_pk, user):
# Note: we do not filter ref_type and ref_pk.
# - ref_type is a class name so upper-cased letters are allowed.
# - ref_pk is already a valid key.
return "%s/%s/%s" % (ref_type, ref_pk, user.email.lower())
@classmethod
def create(cls, ref_type, ref_pk, user, rating):
pk = cls._make_pk(ref_type, ref_pk, user)
rating = max(cls.MIN_RATING, min(cls.MAX_RATING, rating))
return cls(
key_name=pk,
ref_type=ref_type,
ref_pk=str(ref_pk),
user=user,
rating=rating
)
@classmethod
def create_fan(cls, ref_type, ref_pk, user):
pk = cls._make_pk(ref_type, ref_pk, user)
return cls(
key_name=pk,
ref_type=ref_type,
ref_pk=str(ref_pk),
user=user,
rating=cls.MAX_RATING
)
@classmethod
def get_unique(cls, ref_type, ref_pk, user):
pk = cls._make_pk(ref_type, ref_pk, user)
try:
instance = cls.objects.get(pk=pk)
except cls.DoesNotExist:
instance = None
return instance
@classmethod
def find(cls, ref_type, ref_pk, **kwargs):
query = cls.objects.filter(ref_type=ref_type, ref_pk=str(ref_pk)).order_by("-rate_date")
if kwargs.get("limit"):
query.set_limit(kwargs["limit"])
return query
@classmethod
def find_fans(cls, ref_type, ref_pk):
query = cls.objects.filter(ref_type=ref_type, ref_pk=str(ref_pk), rating=cls.MAX_RATING)
return query
@classmethod
def delete_related(cls, ref_type, ref_pk):
deleted = 0
query = cls.objects.filter(ref_type=ref_type, ref_pk=str(ref_pk))
for instance in query:
instance.delete()
deleted += 1
return deleted
class Fave(models.Model):
ref_type = db.StringProperty(required=True)
ref_pk = db.StringProperty(required=True)
user = db.ReferenceProperty(users.User, required=True)
add_date = db.DateTimeProperty(auto_now_add=True)
schema_version = db.IntegerProperty(required=True, default=1)
@classmethod
def _make_pk(cls, ref_type, ref_pk, user):
# Note: we do not filter ref_type and ref_pk.
# - ref_type is a class name so upper-cased letters are allowed.
# - ref_pk is already a valid key.
return "%s/%s/%s" % (ref_type, ref_pk, user.email.lower())
@classmethod
def create(cls, ref_type, ref_pk, user):
pk = cls._make_pk(ref_type, ref_pk, user)
return cls(key_name=pk, ref_type=ref_type, ref_pk=str(ref_pk), user=user)
@classmethod
def get_unique(cls, ref_type, ref_pk, user):
pk = cls._make_pk(ref_type, ref_pk, user)
try:
instance = cls.objects.get(pk=pk)
except cls.DoesNotExist:
instance = None
return instance
@classmethod
def find_by_user(cls, ref_type, user, **kwargs):
query = cls.objects.filter(ref_type=ref_type, user=user).order_by("-add_date")
if kwargs.get("limit"):
query.set_limit(kwargs["limit"])
return query
@classmethod
def find_by_ref(cls, ref_type, ref_pk, **kwargs):
query = cls.objects.filter(ref_type=ref_type, ref_pk=str(ref_pk)).order_by("-add_date")
if kwargs.get("limit"):
query.set_limit(kwargs["limit"])
return query
@classmethod
def delete_related(cls, ref_type, ref_pk):
deleted = 0
query = cls.objects.filter(ref_type=ref_type, ref_pk=str(ref_pk))
for instance in query:
instance.delete()
deleted += 1
return deleted
#---------------------------------------------------------------------------------------------------
def delete_related_fans(sender, **kwargs):
if sender != Fan:
try:
instance = kwargs["instance"]
deleted = Fan.delete_related(ref_type=sender.__name__, ref_pk=instance.pk)
if deleted > 0:
logging.info("%s related fans have been deleted successfully." % deleted)
except Exception, exc:
logging.error("Failed to delete related fans of instance: %s" % exc)
logging.exception(exc)
def delete_related_faves(sender, **kwargs):
if sender != Fave:
try:
instance = kwargs["instance"]
deleted = Fave.delete_related(ref_type=sender.__name__, ref_pk=instance.pk)
if deleted > 0:
logging.info("%s related faves have been deleted successfully." % deleted)
except Exception, exc:
logging.error("Failed to delete related faves of instance: %s" % exc)
logging.exception(exc)
pre_delete.connect(delete_related_fans)
pre_delete.connect(delete_related_faves)
# EOF
| zzheng | friday/website/friday/apps/ilike/models.py | Python | asf20 | 5,789 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-05-13.
# $Id$
#
import logging
from django import template
from friday.common.errors import ProgrammingError
from friday.apps.ilike.models import Fan, Fave
register = template.Library()
class WithFanOrFaveNode(template.Node):
def __init__(self, model_class, instance, user, name, nodelist):
self.model_class = model_class
self.instance = instance
self.user = user
self.name = name
self.nodelist = nodelist
def render(self, context):
instance = self.instance.resolve(context)
user = self.user.resolve(context)
if instance is not None and user is not None:
fan_or_fave = self.model_class.get_unique(
ref_type=instance.__class__.__name__,
ref_pk=instance.pk,
user=user
)
else:
fan_or_fave = None
context.push()
context[self.name] = fan_or_fave
output = self.nodelist.render(context)
context.pop()
return output
def with_fan_or_fave(model_class, parser, token):
_END_TAGS = {
Fan: ("endwithfan",),
Fave: ("endwithfave",),
}
if model_class not in _END_TAGS:
message = "Invalid model class %s in with fan or fave tag." % model_class.__name__
logging.error(message)
raise ProgrammingError(message)
end_tags = _END_TAGS[model_class]
bits = list(token.split_contents())
if len(bits) != 5 or bits[3] != "as":
raise TemplateSyntaxError("%r expected format is 'instance user as name'" % bits[0])
instance = parser.compile_filter(bits[1])
user = parser.compile_filter(bits[2])
name = bits[4]
nodelist = parser.parse(end_tags)
parser.delete_first_token()
return WithFanOrFaveNode(model_class, instance, user, name, nodelist)
@register.tag
def withfan(parser, token):
return with_fan_or_fave(Fan, parser, token)
@register.tag
def withfave(parser, token):
return with_fan_or_fave(Fave, parser, token)
# EOF
| zzheng | friday/website/friday/apps/ilike/templatetags/ilike_tags.py | Python | asf20 | 2,225 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-05-13.
# $Id$
#
| zzheng | friday/website/friday/apps/ilike/templatetags/__init__.py | Python | asf20 | 150 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-05-11.
# $Id$
#
| zzheng | friday/website/friday/apps/ilike/__init__.py | Python | asf20 | 150 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-02-08.
# $Id$
#
import csv
import datetime
import logging
from django import forms
from django.conf import settings
from friday.auth import users
from friday.common.errors import ProgrammingError, InvalidFormError
from friday.apps.groups.models import Group, Member
from friday.apps.restos.models import Resto
class DatabaseImportForm(forms.Form):
csv_file = forms.FileField(required=True)
def import_to_database(self):
if not self.is_valid():
raise InvalidFormError(self.errors)
csv_file = self.cleaned_data["csv_file"]
csv_data = csv.reader(csv_file)
imported, ignored, failed = 0, 0, 0
for csv_row in csv_data:
try:
csv_row = [unicode(cell, "utf-8") for cell in csv_row]
instance = self.create_instance(csv_row)
if instance is not None:
instance.save()
imported += 1
else:
ignored += 1
except Exception, exc:
logging.error("Failed to import CSV row to database: %s" % exc)
logging.error("--> %s" % csv_row)
logging.exception(exc)
failed += 1
return imported, ignored, failed
def create_instance(self, csv_row):
raise NotImplementedError("create_instance() should be implemented by sub-classes.")
class ImportMembersForm(DatabaseImportForm):
_EMAIL_DOMAIN = getattr(settings, "MY_EMAIL_DOMAIN", None)
group = forms.CharField(max_length=64, required=True)
def clean_group(self):
group_uid = self.cleaned_data["group"]
group = Group.get_unique(uid=group_uid)
if group is None:
message = "Group %s cannot be found." % group_uid
raise forms.ValidationError(message)
return group
def create_instance(self, csv_row):
# Ignore all emails that are not in the supported domain.
email = csv_row[0].lower()
if not email.endswith("@" + self._EMAIL_DOMAIN):
return None
# Ignore all members that already exist.
group = self.cleaned_data["group"]
user = users.get_user(email)
if Member.get_unique(group=group, user=user) is not None:
return None
# Create a new Member instance.
if csv_row[2] == "manager" or csv_row[2] == "owner":
role = Member.MODERATOR
else:
role = Member.MEMBER
join_date = datetime.date(int(csv_row[6]), int(csv_row[7]), int(csv_row[8]))
return Member.create(
user=user,
group=group,
role=role,
join_date=join_date,
is_approved=True
)
def import_members(self):
if not self._EMAIL_DOMAIN:
message = "Failed to import members: email domain not defeind in settings."
raise ProgrammingError(message)
return self.import_to_database()
class ImportRestosForm(DatabaseImportForm):
submitter = users.get_user("heavyzheng")
categories = [category for category, display in Resto.CATEGORIES]
def create_instance(self, csv_row):
name = csv_row[0].strip()
category = csv_row[7].strip()
if category not in self.categories:
return None
city = csv_row[3].strip()
if city != u"巴黎":
return None
city = u"Paris"
address = csv_row[1].strip()
route = csv_row[2].strip()
tel_1 = csv_row[4].strip() or None
resto = Resto.create(
name=name,
category=category,
address=address,
route=route,
city=city,
tel_1=tel_1,
submitter=self.submitter
)
return resto
def import_restos(self):
return self.import_to_database()
# EOF
| zzheng | friday/website/friday/apps/admin/forms.py | Python | asf20 | 4,132 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-02-08.
# $Id$
#
from django.conf.urls.defaults import *
from friday.apps.admin.views import *
urlpatterns = patterns("",
url(
r"^$",
admin_home,
name="friday.admin_home"
),
url(
r"^view_environ/$",
view_environ,
name="friday.view_environ"
),
url(
r"^update_datastore/$",
update_datastore,
name="friday.update_datastore"
),
url(
r"^import_members/$",
import_members,
name="friday.import_members"
),
url(
r"^import_restos/$",
import_restos,
name="friday.import_restos"
),
)
# EOF
| zzheng | friday/website/friday/apps/admin/urls.py | Python | asf20 | 815 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-04-23.
# $Id$
#
| zzheng | friday/website/friday/apps/admin/__init__.py | Python | asf20 | 150 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-02-08.
# $Id$
#
import datetime
import logging
import os
import sys
import urllib
from django.conf import settings
from django.http import HttpRequest, HttpResponse, HttpResponseRedirect
from django.template import RequestContext
from django.shortcuts import render_to_response
from django.core.urlresolvers import reverse
from friday.auth import users
from friday.common.actions import WebmasterAction
from friday.common.errors import BadRequestError, InvalidFormError
from friday.common.prompt import Prompt
from friday.apps.admin.forms import ImportMembersForm, ImportRestosForm
class AdminHome(WebmasterAction):
PAGE_URL_NAME = "friday.admin_home"
PAGE_TEMPLATE = "admin/home.html"
def get_page(self):
data = {}
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
class ViewEnviron(WebmasterAction):
PAGE_URL_NAME = "friday.view_environ"
PAGE_TEMPLATE = "admin/view_environ.html"
def get_page(self):
django_settings = []
for name in settings.get_all_members():
if name != "get_all_members" and not name.startswith("_"):
value = getattr(settings, name, None)
django_settings.append("%s = %s" % (name, value))
os_environ = ["%s = %s" % (key, value) for key, value in os.environ.items()]
sys_path = sys.path
cookies = ["%s = %s" % (key, value) for key, value in self.request.COOKIES.items()]
request_meta = ["%s = %s" % (key, value) for key, value in self.request.META.items()]
data = {
"django_settings": django_settings,
"os_environ": os_environ,
"sys_path": sys_path,
"cookies": cookies,
"request_meta": request_meta,
}
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
class UpdateDatastore(WebmasterAction):
PAGE_URL_NAME = "friday.update_datastore"
PAGE_TEMPLATE = "admin/update_datastore.html"
def get_page(self):
data = {"message": self.request.GET.get("message")}
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
def post_page(self):
message = "Nothing to be done."
redirect_url = "%s?%s" % (self.request.path, urllib.urlencode({"message": message}))
return HttpResponseRedirect(redirect_url)
class ImportMembers(WebmasterAction):
PAGE_URL_NAME = "friday.import_members"
PAGE_TEMPLATE = "admin/import_members.html"
def get_page(self):
data = {
"prompt": Prompt(request=self.request),
"import_members_form": ImportMembersForm(),
}
data = self.update_data(data)
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
def post_page(self):
import_members_form = ImportMembersForm(data=self.request.POST, files=self.request.FILES)
try:
imported, ignored, failed = issue = import_members_form.import_members()
message = "Imported %s members, %s entries ignored, %s entries failed." \
% (imported, ignored, failed)
logging.info(message)
prompt = Prompt(info=message)
redirect_url = "%s?%s" % (self.get_page_url(), prompt.urlencode())
return HttpResponseRedirect(redirect_url)
except Exception, exc:
message = "Failed to import members: %s" % exc
logging.error(message)
logging.exception(exc)
data = {"import_members_form": import_members_form}
data = self.update_data(data)
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
class ImportRestos(WebmasterAction):
PAGE_URL_NAME = "friday.import_restos"
PAGE_TEMPLATE = "admin/import_restos.html"
def get_page(self):
data = {
"prompt": Prompt(request=self.request),
"import_restos_form": ImportRestosForm(),
}
data = self.update_data(data)
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
def post_page(self):
import_restos_form = ImportRestosForm(data=self.request.POST, files=self.request.FILES)
try:
imported, ignored, failed = issue = import_restos_form.import_restos()
message = "Imported %s restos, %s entries ignored, %s entries failed." \
% (imported, ignored, failed)
logging.info(message)
prompt = Prompt(info=message)
redirect_url = "%s?%s" % (self.get_page_url(), prompt.urlencode())
return HttpResponseRedirect(redirect_url)
except Exception, exc:
message = "Failed to import members: %s" % exc
logging.error(message)
logging.exception(exc)
data = {"import_restos_form": import_restos_form}
data = self.update_data(data)
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
#---------------------------------------------------------------------------------------------------
def admin_home(request):
return AdminHome(request).process()
def view_environ(request):
return ViewEnviron(request).process()
def update_datastore(request):
return UpdateDatastore(request).process()
def import_members(request):
return ImportMembers(request).process()
def import_restos(request):
return ImportRestos(request).process()
# EOF
| zzheng | friday/website/friday/apps/admin/views.py | Python | asf20 | 5,883 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-02-18.
# $Id$
#
import logging
from google.appengine.ext import db
from djangomockup import models
from djangomockup.models.signals import pre_delete
from friday.auth import users
from friday.common.dbutils import filter_key, ord_to_key
from friday.apps.tagging.models import Taggable
from friday.apps.ilike.models import Fan, Fave
_RESTO_CATEGORIES = (
("chinese", "Chinese Food"),
("japanese", "Japanese Food"),
("korean", "Korean Food"),
("southeast_asian", "Southeast Asian Food"),
("french", "French Food"),
("italian", "Italian Food"),
("misc", "Misc."),
)
_DEFAULT_RESTO_CATEGORY = "misc"
class Resto(models.Model, Taggable):
CATEGORIES = _RESTO_CATEGORIES
DEFAULT_CATEGORY = _DEFAULT_RESTO_CATEGORY
tags_attr = "tags" # Required by Taggable mixin class.
name = db.StringProperty(required=True)
description = db.TextProperty()
category = db.StringProperty(
required=True,
choices=[category for category, display in _RESTO_CATEGORIES],
default=_DEFAULT_RESTO_CATEGORY
)
address = db.PostalAddressProperty(required=True)
city = db.StringProperty(required=True)
geo_pt = db.GeoPtProperty()
post_code = db.StringProperty()
route = db.StringProperty()
tel_1 = db.PhoneNumberProperty()
tel_2 = db.PhoneNumberProperty()
website = db.LinkProperty()
hours_1 = db.StringProperty()
hours_2 = db.StringProperty()
hours_3 = db.StringProperty()
places = db.IntegerProperty()
tags = db.StringListProperty(default=[])
background_url = db.LinkProperty()
logo_icon_url = db.LinkProperty()
popularity = db.IntegerProperty(required=True, default=0)
owner = db.ReferenceProperty(users.User, required=False, collection_name="owned_restos")
submitter = db.ReferenceProperty(users.User, required=True, collection_name="submitted_restos")
submit_date = db.DateTimeProperty(required=True, auto_now_add=True)
updater = db.ReferenceProperty(users.User, required=True, collection_name="updated_restos")
update_date = db.DateTimeProperty(required=True, auto_now=True)
schema_version = db.IntegerProperty(required=True, default=1)
@property
def model_name(self):
return self.__class__.__name__
@property
def tels(self):
tel_list = []
if self.tel_1:
tel_list.append(self.tel_1)
if self.tel_2:
tel_list.append(self.tel_2)
return tel_list
@property
def hours(self):
hours_list = []
if self.hours_1:
hours_list.append(self.hours_1)
if self.hours_2:
hours_list.append(self.hours_2)
if self.hours_3:
hours_list.append(self.hours_3)
return hours_list
@property
def dishes(self):
return Dish.find_by_resto(resto=self)
@property
def faves(self):
return Fave.find_by_ref(ref_type=self.__class__.__name__, ref_pk=self.id)
def __unicode__(self):
return unicode(self.name)
def change_fave(self, user):
fave = Fave.get_unique(ref_type=self.__class__.__name__, ref_pk=self.id, user=user)
if fave is None:
fave = Fave.create(ref_type=self.__class__.__name__, ref_pk=self.id, user=user)
fave.save()
self.popularity += 5
else:
fave.delete()
self.popularity = max(0, self.popularity - 5)
self.save()
def get_category_display(self):
for category, display in self.CATEGORIES:
if category == self.category:
return display
return self.category
def delete(self):
if self.tags:
self.remove_tags(",".join(self.tags))
return super(Resto, self).delete()
@classmethod
def get_unique(cls, id):
try:
instance = cls.objects.get(id=id)
except cls.DoesNotExist:
instance = None
return instance
@classmethod
def create(cls, submitter, **kwargs):
return cls(submitter=submitter, updater=submitter, **kwargs)
@classmethod
def find(cls, **kwargs):
query = cls.objects.order_by(kwargs.get("order_by") or "-popularity")
if kwargs.get("cursor"):
query.with_cursor(kwargs["cursor"])
if kwargs.get("limit"):
query.set_limit(kwargs["limit"])
return query
@classmethod
def find_by_category(cls, category, **kwargs):
query = cls.objects.filter(category=category)
query = query.order_by(kwargs.get("order_by") or "-popularity")
if kwargs.get("cursor"):
query.with_cursor(kwargs["cursor"])
if kwargs.get("limit"):
query.set_limit(kwargs["limit"])
return query
@classmethod
def find_by_tag(cls, name, **kwargs):
if "order_by" not in kwargs:
kwargs["order_by"] = "-popularity"
return super(Resto, cls).find_by_tag(name=name, **kwargs)
class Dish(models.Model):
resto = db.ReferenceProperty(Resto, required=True)
name = db.StringProperty(required=True)
description = db.TextProperty()
photo_url = db.LinkProperty()
is_spicy = db.BooleanProperty(required=True, default=False)
is_vegetarian = db.BooleanProperty(required=True, default=False)
price = db.StringProperty()
popularity = db.IntegerProperty(required=True, default=0)
schema_version = db.IntegerProperty(required=True, default=1)
@property
def fans(self):
return Fan.find_fans(ref_type=self.__class__.__name__, ref_pk=self.id)
def __unicode__(self):
return unicode(self.name)
def change_fan(self, user):
fan = Fan.get_unique(ref_type=self.__class__.__name__, ref_pk=self.id, user=user)
if fan is None:
fan = Fan.create_fan(ref_type=self.__class__.__name__, ref_pk=self.id, user=user)
fan.save()
self.popularity += 1
self.resto.popularity += 1
else:
fan.delete()
self.popularity = max(0, self.popularity - 1)
self.resto.popularity = max(0, self.resto.popularity - 1)
self.save()
self.resto.save()
@classmethod
def create(cls, **kwargs):
return cls(**kwargs)
@classmethod
def get_unique(cls, id):
try:
instance = cls.objects.get(id=id)
except cls.DoesNotExist:
instance = None
return instance
@classmethod
def find_by_resto(cls, resto):
query = cls.objects.filter(resto=resto).order_by("-popularity")
return query
@classmethod
def find_by_name(cls, name):
query = cls.objects.filter(name=name).order_by("-popularity")
return query
@classmethod
def delete_related(cls, resto):
deleted = 0
query = cls.objects.filter(resto=resto)
for instance in query:
instance.delete()
deleted += 1
return deleted
#---------------------------------------------------------------------------------------------------
def delete_related_dishes(sender, **kwargs):
if sender == Resto:
try:
resto = kwargs["instance"]
deleted = Dish.delete_related(resto=resto)
if deleted > 0:
logging.info("%s related dishes have been deleted successfully." % deleted)
except Exception, exc:
logging.error("Failed to delete related dishes on resto: %s" % exc)
logging.exception(exc)
pre_delete.connect(delete_related_dishes, sender=Resto)
# EOF
| zzheng | friday/website/friday/apps/restos/models.py | Python | asf20 | 7,998 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-02-18.
# $Id$
#
from friday.auth import users
from friday.apps.restos.models import Resto
class RestoAccess(object):
def __init__(self, user, resto):
self._user = user
self._resto = resto
def can_edit(self):
if users.is_webmaster(self._user):
return True
if self._user and self._user.is_staff:
return True
if self._user and self._resto.owner:
return self._user == self._resto.owner
return False
def can_delete(self):
if users.is_webmaster(self._user):
return True
if self._user and self._resto.owner:
return self._user == self._resto.owner
return False
# EOF
| zzheng | friday/website/friday/apps/restos/access.py | Python | asf20 | 874 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-02-18.
# $Id$
#
import logging
from django import forms
from friday.common.errors import ProgrammingError, InvalidFormError
from friday.common.fields import GeoPtField
from friday.apps.restos.models import Resto, Dish
class RestoForm(forms.Form):
name = forms.CharField(required=True)
description = forms.CharField(required=False, widget=forms.Textarea)
category = forms.ChoiceField(choices=Resto.CATEGORIES, required=True)
address = forms.CharField(required=True)
city = forms.CharField(required=True)
geo_pt = GeoPtField(required=False)
post_code = forms.CharField(required=False)
route = forms.CharField(required=False)
tel_1 = forms.CharField(required=False)
tel_2 = forms.CharField(required=False)
website = forms.URLField(required=False)
hours_1 = forms.CharField(required=False)
hours_2 = forms.CharField(required=False)
hours_3 = forms.CharField(required=False)
places = forms.IntegerField(required=False)
def __init__(self, data=None, instance=None):
self._instance = instance
if instance:
initial = {
"name": instance.name,
"description": instance.description,
"category": instance.category,
"address": instance.address,
"city": instance.city,
"geo_pt": instance.geo_pt,
"post_code": instance.post_code,
"route": instance.route,
"tel_1": instance.tel_1,
"tel_2": instance.tel_2,
"website": instance.website,
"hours_1": instance.hours_1,
"hours_2": instance.hours_2,
"hours_3": instance.hours_3,
"places": instance.places,
}
else:
initial = None
super(RestoForm, self).__init__(data=data, initial=initial)
@property
def instance(self):
return self._instance
def clean_website(self):
return self.cleaned_data["website"] or None
def clean_tel_1(self):
return self.cleaned_data["tel_1"] or None
def clean_tel_2(self):
return self.cleaned_data["tel_2"] or None
def create(self, submitter):
if self._instance is not None:
message = "Failed to create resto: this form is bound to an existing resto."
raise ProgrammingError(message)
if not self.is_valid():
raise InvalidFormError(self.errors)
instance = Resto.create(submitter=submitter, **self.cleaned_data)
instance.save()
return instance
def update(self, updater):
if self._instance is None:
message = "Failed to update resto: this form is not bound to an resto."
raise ProgrammingError(message)
if not self.is_valid():
raise InvalidFormError(self.errors)
for name, value in self.cleaned_data.items():
setattr(self._instance, name, value)
self._instance.updater = updater
self._instance.save()
return self._instance
class RestoTagForm(forms.Form):
names = forms.CharField(required=False)
def add_tags(self, resto):
if not self.is_valid():
raise InvalidFormError(self.errors)
resto.add_tags(self.cleaned_data["names"])
resto.save()
return resto
class DishForm(forms.Form):
name = forms.CharField(required=True)
description = forms.CharField(required=False, widget=forms.Textarea)
photo_url = forms.URLField(required=False)
is_spicy = forms.BooleanField(required=False)
is_vegetarian = forms.BooleanField(required=False)
price = forms.CharField(required=False)
def __init__(self, data=None, instance=None):
self._instance = instance
if instance:
initial = {
"name": instance.name,
"description": instance.description,
"photo_url": instance.photo_url,
"is_spicy": instance.is_spicy,
"is_vegetarian": instance.is_vegetarian,
"price": instance.price,
}
else:
initial = None
super(DishForm, self).__init__(data=data, initial=initial)
@property
def instance(self):
return self._instance
def clean_photo_url(self):
return self.cleaned_data["photo_url"] or None
def create(self, resto):
if self._instance is not None:
message = "Failed to create dish: this form is bound to an existing instance."
raise ProgrammingError(message)
if not self.is_valid():
raise InvalidFormError(self.errors)
instance = Dish.create(resto=resto, **self.cleaned_data)
instance.save()
return instance
def update(self):
if self._instance is None:
message = "Failed to update dish: this form is not bound to an instance."
raise ProgrammingError(message)
if not self.is_valid():
raise InvalidFormError(self.errors)
if self._instance.name != self.cleaned_data["name"]:
message = "Dish name is read-only, and cannot be updated."
raise ProgrammingError(message)
for name, value in self.cleaned_data.items():
if name != "name":
setattr(self._instance, name, value)
self._instance.save()
return self._instance
# EOF
| zzheng | friday/website/friday/apps/restos/forms.py | Python | asf20 | 5,754 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-02-08.
# $Id$
#
from django.conf.urls.defaults import *
from friday.apps.restos.views import *
urlpatterns = patterns("",
url(
r"^$",
restos_home,
name="friday.restos_home"
),
url(
r"^all/$",
view_all_restos,
name="friday.view_all_restos"
),
url(
r"^category/(?P<category>\w+)/$",
view_restos_by_category,
name="friday.view_restos_by_category"
),
url(
r"^tag_cloud/$",
view_resto_tag_cloud,
name="friday.view_resto_tag_cloud"
),
url(
r"^tag/$",
view_restos_by_tag,
name="friday.view_restos_by_tag"
),
url(
r"^create/$",
create_resto,
name="friday.create_resto"
),
url(
r"^(?P<resto_id>\d+)/$",
view_resto,
name="friday.view_resto"
),
url(
r"^(?P<resto_id>\d+)/tags/$",
view_resto_tags,
name="friday.view_resto_tags"
),
url(
r"^(?P<resto_id>\d+)/remove_tag/$",
remove_resto_tag,
name="friday.remove_resto_tag"
),
url(
r"^(?P<resto_id>\d+)/edit/$",
edit_resto,
name="friday.edit_resto"
),
url(
r"^(?P<resto_id>\d+)/delete/$",
delete_resto,
name="friday.delete_resto"
),
url(
r"^(?P<resto_id>\d+)/change_fave/$",
change_resto_fave,
name="friday.change_resto_fave"
),
url(
r"^(?P<resto_id>\d+)/recommend/$",
recommend_dish,
name="friday.recommend_dish"
),
url(
r"^(?P<resto_id>\d+)/(?P<dish_id>\d+)/change_fan/$",
change_dish_fan,
name="friday.change_dish_fan"
),
url(
r"^(?P<resto_id>\d+)/(?P<dish_id>\d+)/edit/$",
edit_dish,
name="friday.edit_dish"
),
url(
r"^(?P<resto_id>\d+)/(?P<dish_id>\d+)/delete/$",
delete_dish,
name="friday.delete_dish"
),
url(
r"^dish/$",
search_dish,
name="friday.search_dish"
),
)
# EOF
| zzheng | friday/website/friday/apps/restos/urls.py | Python | asf20 | 2,294 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-02-18.
# $Id$
#
| zzheng | friday/website/friday/apps/restos/__init__.py | Python | asf20 | 150 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-02-18.
# $Id$
#
import hashlib
import logging
import random
import urllib
from django.http import HttpRequest, HttpResponse, HttpResponseRedirect
from django.template import RequestContext
from django.shortcuts import render_to_response
from friday.common.errors import BadRequestError, InvalidFormError, EntityNotFoundError
from friday.common.prompt import Prompt
from friday.common.actions import Action
from friday.apps.comments.models import Comment
from friday.apps.tagging.models import Tag
from friday.apps.restos.models import Resto, Dish
from friday.apps.restos.access import RestoAccess
from friday.apps.restos.forms import RestoForm, RestoTagForm, DishForm
class RestosHome(Action):
PAGE_URL_NAME = "friday.restos_home"
PAGE_TEMPLATE = "restos/home.html"
def get_page(self):
# Find newly added restos (randomly select 4 out of 10).
newly_added_restos = list(Resto.find(order_by="-update_date", limit=10))
random.shuffle(newly_added_restos)
newly_added_restos = newly_added_restos[:4]
# Find newly commented restos (a list of 2-tuple with resto and comment).
new_comments = Comment.find_recent(ref_type=Resto.__name__, limit=4)
newly_commented_restos = []
for comment in new_comments:
resto = Resto.get_unique(id=int(comment.ref_pk))
if resto:
newly_commented_restos.append((resto, comment))
# Render the response.
data = {
"categories": Resto.CATEGORIES,
"newly_added_restos": newly_added_restos,
"newly_commented_restos": newly_commented_restos,
}
data = self.update_data(data)
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
class ViewAllRestos(Action):
PAGE_URL_NAME = "friday.view_all_restos"
PAGE_TEMPLATE = "restos/view_all_restos.html"
def get_page(self):
cursor = self.request.GET.get("cursor") or None
data = {
"categories": Resto.CATEGORIES,
"restos": Resto.find(cursor=cursor, limit=20),
}
data = self.update_data(data)
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
class ViewRestosByCategory(Action):
PAGE_URL_NAME = "friday.view_restos_by_category"
PAGE_TEMPLATE = "restos/view_restos_by_category.html"
def __init__(self, request, category):
super(ViewRestosByCategory, self).__init__(request)
self.category = category
def get_page(self):
category_display = None
for category, display in Resto.CATEGORIES:
if category == self.category:
category_display = display
break
category_display = category_display or self.category
cursor = self.request.GET.get("cursor") or None
restos = Resto.find_by_category(category=self.category, cursor=cursor, limit=20)
data = {
"categories": Resto.CATEGORIES,
"category_display": category_display,
"restos": restos,
}
data = self.update_data(data)
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
class ViewRestoTagCloud(Action):
AJAX_URL_NAME = "friday.view_resto_tag_cloud"
AJAX_TEMPLATE = "restos/common/resto_tag_cloud.html"
def get_ajax(self):
return {"tag_cloud": Tag.get_cloud(Resto)}
class ViewRestosByTag(Action):
PAGE_URL_NAME = "friday.view_restos_by_tag"
PAGE_TEMPLATE = "restos/view_restos_by_tag.html"
def get_page(self):
tag_name = self.request.GET.get("tag_name")
cursor = self.request.GET.get("cursor") or None
restos = Resto.find_by_tag(name=tag_name, cursor=cursor, limit=20)
data = {"tag_name": tag_name, "restos": restos}
data = self.update_data(data)
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
class CreateResto(Action):
PAGE_URL_NAME = "friday.create_resto"
PAGE_TEMPLATE = "restos/create_resto.html"
def _check_create_access(self):
if not self.current_user:
message = "Current user cannot create resto."
logging.error(message)
raise BadRequestError(self.request, message)
def get_page(self):
self._check_create_access()
data = {"resto_form": RestoForm()}
data = self.update_data(data)
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
def post_page(self):
self._check_create_access()
resto_form = RestoForm(data=self.request.POST)
try:
resto = resto_form.create(submitter=self.current_user)
redirect_url = ViewResto.get_page_url(resto_id=resto.id)
return HttpResponseRedirect(redirect_url)
except Exception, exc:
message = "Failed to create resto in datastore: %s" % exc
logging.error(message)
logging.exception(exc)
data = {"resto_form": resto_form, "prompt": Prompt(error=message)}
data = self.update_data(data)
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
class BaseRestoAction(Action):
def __init__(self, request, resto_id):
super(BaseRestoAction, self).__init__(request)
self.resto_id = int(resto_id)
def get_resto(self):
resto = Resto.get_unique(id=self.resto_id)
if not resto:
message = "searched by resto id %s." % self.resto_id
raise EntityNotFoundError(Resto, message)
return resto
def get_resto_access(self):
return RestoAccess(self.current_user, self.get_resto())
def update_data(self, data):
data["resto"] = self.get_resto()
data["resto_access"] = self.get_resto_access()
return super(BaseRestoAction, self).update_data(data)
class ViewResto(BaseRestoAction):
PAGE_URL_NAME = "friday.view_resto"
PAGE_TEMPLATE = "restos/view_resto.html"
def get_page(self):
data = self.update_data({})
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
class ViewRestoTags(BaseRestoAction):
AJAX_URL_NAME = "friday.view_resto_tags"
AJAX_TEMPLATE = "restos/common/resto_tags.html"
def get_ajax(self):
if self.get_resto_access().can_edit():
return {"resto_tag_form": RestoTagForm()}
else:
return {}
def post_ajax(self):
if not self.get_resto_access().can_edit():
message = "Current user cannot add tags to resto."
raise BadRequestError(self.request, message)
resto_tag_form = RestoTagForm(data=self.request.POST)
try:
resto_tag_form.add_tags(resto=self.get_resto())
return {"resto_tag_form": RestoTagForm()}
except Exception, exc:
message = "Failed to add tags to resto: %s" % exc
logging.error(message)
logging.exception(exc)
return {"ajax_prompt": Prompt(error=message), "resto_tag_form": resto_tag_form}
class RemoveRestoTag(BaseRestoAction):
AJAX_URL_NAME = "friday.remove_resto_tag"
AJAX_TEMPLATE = "restos/common/resto_tag_removed.html"
def post_ajax(self):
if not self.get_resto_access().can_edit():
message = "Current user cannot add tags to resto"
raise BadRequestError(self.request, message)
resto = self.get_resto()
name = self.request.POST.get("name")
try:
resto.remove_tags(name)
resto.save()
return {"name": name}
except Exception, exc:
message = "Failed to remove tag from resto: %s" % exc
logging.error(message)
logging.exception(exc)
return {"ajax_prompt": Prompt(error=message), "name": name}
class EditResto(BaseRestoAction):
PAGE_URL_NAME = "friday.edit_resto"
PAGE_TEMPLATE = "restos/edit_resto.html"
def _check_edit_access(self):
if not self.get_resto_access().can_edit():
message = "Current user cannot edit resto %s." % self.get_resto().id
logging.error(message)
raise BadRequestError(self.request, message)
def get_page(self):
self._check_edit_access()
resto_form = RestoForm(instance=self.get_resto())
data = {"resto_form": resto_form}
data = self.update_data(data)
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
def post_page(self):
self._check_edit_access()
resto_form = RestoForm(data=self.request.POST, instance=self.get_resto())
try:
resto = resto_form.update(updater=self.current_user)
message = "Resto %s has been updated successfully." % resto.id
logging.info(message)
redirect_url = ViewResto.get_page_url(resto_id=resto.id)
return HttpResponseRedirect(redirect_url)
except Exception, exc:
message = "Failed to update resto in datastore: %s" % exc
logging.error(message)
logging.exception(exc)
data = {"resto_form": resto_form, "prompt": Prompt(error=message)}
data = self.update_data(data)
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
class DeleteResto(BaseRestoAction):
PAGE_URL_NAME = "friday.delete_resto"
PAGE_TEMPLATE = "restos/delete_resto.html"
def _check_delete_access(self):
if not self.get_resto_access().can_delete():
message = "Current user cannot delete resto %s." % self.get_resto().id
logging.error(message)
raise BadRequestError(self.request, message)
def get_page(self):
self._check_delete_access()
data = self.update_data({})
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
def post_page(self):
self._check_delete_access()
try:
resto = self.get_resto()
resto_id = resto.id # Resto instance has no 'id' attribute after deletion.
resto.delete()
message = "Resto %s has been deleted successfully." % resto_id
logging.info(message)
redirect_url = ViewAllRestos.get_page_url()
return HttpResponseRedirect(redirect_url)
except Exception, exc:
message = "Failed to delete resto in datastore: %s" % exc
logging.error(message)
logging.exception(exc)
data = {"prompt": Prompt(error=message)}
data = self.update_data(data)
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
class ChangeRestoFave(BaseRestoAction):
AJAX_URL_NAME = "friday.change_resto_fave"
AJAX_TEMPLATE = "restos/common/resto_faves.html"
def post_ajax(self):
if not self.current_user:
message = "Anonymous user cannot add/remove a resto to/from faves."
raise BadRequestError(self.request, message)
resto = self.get_resto()
resto.change_fave(self.current_user)
return {}
class RecommendDish(BaseRestoAction):
PAGE_URL_NAME = "friday.recommend_dish"
PAGE_TEMPLATE = "restos/recommend_dish.html"
def _check_create_access(self):
if not self.get_resto_access().can_edit():
message = "Current user cannot recommend dish of resto %s." % self.get_resto().id
logging.error(message)
raise BadRequestError(self.request, message)
def get_page(self):
self._check_create_access()
dish_form = DishForm()
data = {"dish_form": dish_form}
data = self.update_data(data)
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
def post_page(self):
self._check_create_access()
dish_form = DishForm(data=self.request.POST)
try:
dish = dish_form.create(resto=self.get_resto())
message = "Dish %s has been created successfully." % dish.id
logging.info(message)
redirect_url = ViewResto.get_page_url(resto_id=dish.resto.id)
return HttpResponseRedirect(redirect_url)
except Exception, exc:
message = "Failed to create dish in datastore: %s" % exc
logging.error(message)
logging.exception(exc)
data = {"dish_form": dish_form, "prompt": Prompt(error=message)}
data = self.update_data(data)
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
class BaseDishAction(BaseRestoAction):
def __init__(self, request, resto_id, dish_id):
super(BaseDishAction, self).__init__(request, resto_id)
self.dish_id = int(dish_id)
def get_dish(self):
dish = Dish.get_unique(id=self.dish_id)
if not dish or dish.resto != self.get_resto():
message = "searched by dish id %s." % self.dish_id
raise EntityNotFoundError(Dish, message)
return dish
def update_data(self, data):
data["dish"] = self.get_dish()
return super(BaseDishAction, self).update_data(data)
class ChangeDishFan(BaseDishAction):
AJAX_URL_NAME = "friday.change_dish_fan"
AJAX_TEMPLATE = "restos/common/dish.html"
def post_ajax(self):
if not self.current_user:
message = "Anonymous user cannot like/unlike a dish."
raise BadRequestError(self.request, message)
dish = self.get_dish()
dish.change_fan(self.current_user)
return {}
class EditDish(BaseDishAction):
PAGE_URL_NAME = "friday.edit_dish"
PAGE_TEMPLATE = "restos/edit_dish.html"
def _check_edit_access(self):
if not self.get_resto_access().can_edit():
message = "Current user cannot edit dish of resto %s." % self.get_resto().id
logging.error(message)
raise BadRequestError(self.request, message)
def get_page(self):
self._check_edit_access()
dish_form = DishForm(instance=self.get_dish())
data = {"dish_form": dish_form}
data = self.update_data(data)
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
def post_page(self):
self._check_edit_access()
dish_form = DishForm(data=self.request.POST, instance=self.get_dish())
try:
dish = dish_form.update()
message = "Dish %s has been updated successfully." % dish.id
logging.info(message)
redirect_url = ViewResto.get_page_url(resto_id=dish.resto.id)
return HttpResponseRedirect(redirect_url)
except Exception, exc:
message = "Failed to update dish in datastore: %s" % exc
logging.error(message)
logging.exception(exc)
data = {"dish_form": dish_form, "prompt": Prompt(error=message)}
data = self.update_data(data)
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
class DeleteDish(BaseDishAction):
PAGE_URL_NAME = "friday.delete_dish"
PAGE_TEMPLATE = "restos/delete_dish.html"
def _check_delete_access(self):
if not self.get_resto_access().can_edit():
message = "Current user cannot delete dish %s." % self.get_dish().id
logging.error(message)
raise BadRequestError(self.request, message)
def get_page(self):
self._check_delete_access()
data = self.update_data({})
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
def post_page(self):
self._check_delete_access()
try:
dish = self.get_dish()
dish_id = dish.id # Dish instance has no 'id' attribute after deletion.
dish.delete()
message = "Dish %s has been deleted successfully." % dish_id
logging.info(message)
redirect_url = ViewResto.get_page_url(resto_id=self.get_resto().id)
return HttpResponseRedirect(redirect_url)
except Exception, exc:
message = "Failed to delete dish in datastore: %s" % exc
logging.error(message)
logging.exception(exc)
data = {"prompt": Prompt(error=message)}
data = self.update_data(data)
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
class SearchDish(Action):
PAGE_URL_NAME = "friday.search_dish"
PAGE_TEMPLATE = "restos/search_dish.html"
def get_page(self):
dish_name = self.request.GET.get("dish_name")
data = {"dish_name": dish_name, "dishes": Dish.find_by_name(dish_name)}
data = self.update_data(data)
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
#---------------------------------------------------------------------------------------------------
def restos_home(request):
return RestosHome(request).process()
def view_all_restos(request):
return ViewAllRestos(request).process()
def view_restos_by_category(request, category):
return ViewRestosByCategory(request, category).process()
def view_resto_tag_cloud(request):
return ViewRestoTagCloud(request).process()
def view_restos_by_tag(request):
return ViewRestosByTag(request).process()
def create_resto(request):
return CreateResto(request).process()
def view_resto(request, resto_id):
return ViewResto(request, resto_id).process()
def view_resto_tags(request, resto_id):
return ViewRestoTags(request, resto_id).process()
def remove_resto_tag(request, resto_id):
return RemoveRestoTag(request, resto_id).process()
def edit_resto(request, resto_id):
return EditResto(request, resto_id).process()
def delete_resto(request, resto_id):
return DeleteResto(request, resto_id).process()
def change_resto_fave(request, resto_id):
return ChangeRestoFave(request, resto_id).process()
def recommend_dish(request, resto_id):
return RecommendDish(request, resto_id).process()
def change_dish_fan(request, resto_id, dish_id):
return ChangeDishFan(request, resto_id, dish_id).process()
def edit_dish(request, resto_id, dish_id):
return EditDish(request, resto_id, dish_id).process()
def delete_dish(request, resto_id, dish_id):
return DeleteDish(request, resto_id, dish_id).process()
def search_dish(request):
return SearchDish(request).process()
# EOF
| zzheng | friday/website/friday/apps/restos/views.py | Python | asf20 | 19,425 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-02-08.
# $Id$
#
from django.conf.urls.defaults import *
from friday.apps.misc.views import *
urlpatterns = patterns("",
url(
r"^$",
welcome,
name="friday.welcome"
),
url(
r"^home/$",
home,
name="friday.home"
),
url(
r"^about/$",
about,
name="friday.about"
),
url(
r"^about/(?P<topic>\w+)/$",
about,
name="friday.about"
),
url(
r"^.*/$",
not_found,
name="friday.not_found"
),
)
# EOF
| zzheng | friday/website/friday/apps/misc/urls.py | Python | asf20 | 718 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-02-08.
# $Id$
#
| zzheng | friday/website/friday/apps/misc/__init__.py | Python | asf20 | 150 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-02-08.
# $Id$
#
import datetime
import urllib
from django.http import HttpRequest, HttpResponse, HttpResponseRedirect
from django.template import RequestContext
from django.shortcuts import render_to_response
from django.core.urlresolvers import reverse
from friday.auth import users
from friday.common.errors import ProgrammingError
class Splash(object):
def __init__(self, isoweekday):
super(Splash, self).__init__()
self.isoweekday = int(isoweekday)
if self.isoweekday == 1:
self.weekday_name = "Monday"
self.image = "the_persistence_of_memory.jpg"
self.title = "The Persistence of Memory (1931)"
self.artist = "Salvador Dali"
elif self.isoweekday == 2:
self.weekday_name = "Tuesday"
self.image = "the_scream.jpg"
self.title = "The Scream (1893)"
self.artist = "Edvard Munch"
elif self.isoweekday == 3:
self.weekday_name = "Wednesday"
self.image = "barge_haulers_on_the_volga.jpg"
self.title = "Barge Haulers on the Volga (1870-1873)"
self.artist = "Ilya Repin"
elif self.isoweekday == 4:
self.weekday_name = "Thursday"
self.image = "the_raft_of_the_medusa.jpg"
self.title = "The Raft of the Medusa (1819)"
self.artist = "Théodore Géricault"
elif self.isoweekday == 5:
self.weekday_name = "Friday"
self.image = "liberty_leading_the_people.jpg"
self.title = "Liberty Leading the People (1830)"
self.artist = "Eugène Delacroix"
elif self.isoweekday == 6:
self.weekday_name = "Saturday"
self.image = "le_moulin_de_la_galette.jpg"
self.title = "Le moulin de la Galette (1876)"
self.artist = "Pierre-Auguste Renoir"
elif self.isoweekday == 7:
self.weekday_name = "Sunday"
self.image = "sunday_afternoon_on_the_island_of_la_grande_jatte.jpg"
self.title = "Sunday Afternoon on the Island of La Grande Jatte (1884-1886)"
self.artist = "Georges Seurat"
else:
message = "Invalid ISO weekday %s." % isoweekday
raise ProgrammingError(message)
@property
def countdown(self):
return max(0, 5 - self.isoweekday)
@property
def is_friday(self):
return self.isoweekday == 5
@property
def is_weekend(self):
return self.isoweekday in (6, 7)
@property
def artist_url(self):
return "http://en.wikipedia.org/wiki/%s" % urllib.quote(self.artist.replace(" ", "_"))
def welcome(request):
current_user = users.get_current_user(request)
if current_user:
redirect_url = reverse("friday.home")
return HttpResponseRedirect(redirect_url)
splash = None
if request.REQUEST.get("isoweekday"):
try:
splash = Splash(request.REQUEST.get("isoweekday"))
except ValueError:
splash = None
splash = splash or Splash(datetime.date.today().isoweekday())
data = {"splash": splash}
return render_to_response("misc/welcome.html", data, RequestContext(request))
def home(request):
# TODO: as we have only one group at this moment, we redirect to the group page.
redirect_url = reverse("friday.view_group", kwargs={"group_uid": "vivelevendredi"})
return HttpResponseRedirect(redirect_url)
#data = {}
#return render_to_response("misc/home.html", data, RequestContext(request))
def about(request, topic=None):
_TOPICS = ("browser", "versions")
if topic not in _TOPICS:
template_file = "misc/about.html"
else:
template_file = "misc/about_%s.html" % topic
data = {}
return render_to_response(template_file, data, RequestContext(request))
def not_found(request):
data = {"bad_url": request.path}
response = render_to_response("misc/not_found.html", data, RequestContext(request))
response.status_code = 404 # not found.
return response
# EOF
| zzheng | friday/website/friday/apps/misc/views.py | Python | asf20 | 4,328 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-05-19.
# $Id$
#
import datetime
import logging
from google.appengine.ext import db
from djangomockup import models
from friday.auth import users
from friday.common.dbutils import filter_key
from friday.apps.groups.models import Group
class GroupStat(models.Model):
group = db.ReferenceProperty(Group, required=True)
start_date = db.DateProperty(required=True)
post_count = db.IntegerProperty(required=True, default=0)
@classmethod
def _make_pk(cls, group, date):
return "%s/%s/%s" % (group.uid, date.year, date.month)
@classmethod
def get_unique(cls, group, date, month_delta=None):
if month_delta:
month_count = date.year * 12 + date.month + month_delta
year = month_count // 12
month = month_count % 12
if month == 0:
year -= 1
month = 12
date = datetime.date(year, month, 1)
pk = cls._make_pk(group, date)
try:
instance = cls.objects.get(pk=pk)
except cls.DoesNotExist:
instance = None
return instance
@classmethod
def get_or_create(cls, group, date):
instance = cls.get_unique(group=group, date=date)
if instance is None:
pk = cls._make_pk(group, date)
instance = cls(key_name=pk, group=group, start_date=date)
instance.save()
return instance
class PosterStat(models.Model):
group_stat = db.ReferenceProperty(GroupStat, required=True)
poster = db.ReferenceProperty(users.User, required=True)
post_count = db.IntegerProperty(required=True, default=0)
def __unicode__(self):
return unicode(self.poster)
@classmethod
def _make_pk(cls, group_stat, poster):
return "%s/%s" % (group_stat.pk, poster.email.lower())
@classmethod
def get_unique(cls, group_stat, poster):
pk = cls._make_pk(group_stat, poster)
try:
instance = cls.objects.get(pk=pk)
except cls.DoesNotExist:
instance = None
return instance
@classmethod
def get_or_create(cls, group_stat, poster):
instance = cls.get_unique(group_stat=group_stat, poster=poster)
if instance is None:
pk = cls._make_pk(group_stat, poster)
instance = cls(key_name=pk, group_stat=group_stat, poster=poster)
instance.save()
return instance
@classmethod
def find_by_group_stat(cls, group_stat, **kwargs):
query = cls.objects.filter(group_stat=group_stat).order_by("-post_count")
if kwargs.get("limit"):
query.set_limit(kwargs["limit"])
return query
#---------------------------------------------------------------------------------------------------
def count_post(subject, poster_email, recipients):
# TODO: currently we support only vivelevendredi Google Group.
RECIPIENT_TO_GROUP_UID = {
"vivelevendredi@googlegroups.com": "vivelevendredi",
}
try:
recipients = [
recipient.lower()
for recipient in recipients
if recipient.lower() in RECIPIENT_TO_GROUP_UID
]
recipients = set(recipients) # to remove duplicates.
for recipient in recipients:
group = Group.get_unique(uid=RECIPIENT_TO_GROUP_UID[recipient])
if group is None:
logging.warning("Ignored recipient %s: group cannot be found." % recipient)
continue
group_stat = GroupStat.get_or_create(group=group, date=datetime.date.today())
group_stat.post_count += 1
group_stat.save()
poster = users.get_user_by_email(poster_email)
if poster is None:
logging.warning("Ignored poster %s: user cannot be found." % poster_email)
else:
poster_stat = PosterStat.get_or_create(group_stat=group_stat, poster=poster)
poster_stat.post_count += 1
poster_stat.save()
except Exception, exc:
logging.error("Failed to count post: %s" % exc)
logging.exception(exc)
# EOF
| zzheng | friday/website/friday/apps/poststats/models.py | Python | asf20 | 4,403 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-02-08.
# $Id$
#
from django.conf.urls.defaults import *
from friday.apps.poststats.views import *
urlpatterns = patterns("",
url(
r"^stat/$",
view_group_stat,
name="friday.view_group_stat"
),
url(
r"^stat/(?P<year>\d{4})/(?P<month>\d{1,2})/$",
view_group_stat,
name="friday.view_group_stat"
),
url(
r"^top_posters/$",
view_top_posters,
name="friday.view_top_posters"
),
)
# EOF
| zzheng | friday/website/friday/apps/poststats/urls.py | Python | asf20 | 641 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-05-19.
# $Id$
#
| zzheng | friday/website/friday/apps/poststats/__init__.py | Python | asf20 | 150 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-05-19.
# $Id$
#
import datetime
from django.http import HttpRequest, HttpResponse, HttpResponseRedirect
from django.template import RequestContext
from django.shortcuts import render_to_response
from friday.apps.groups.views import BaseGroupAction
from friday.apps.poststats.models import GroupStat, PosterStat
class ViewGroupStat(BaseGroupAction):
PAGE_URL_NAME = "friday.view_group_stat"
PAGE_TEMPLATE = "poststats/view_group_stat.html"
def __init__(self, request, group_uid, year=None, month=None):
super(ViewGroupStat, self).__init__(request, group_uid)
if year and month:
self.date = datetime.date(int(year), int(month), 1)
else:
self.date = datetime.date.today()
def get_page(self):
group_stat = GroupStat.get_unique(group=self.get_group(), date=self.date)
if group_stat is not None:
top_posters = PosterStat.find_by_group_stat(group_stat=group_stat, limit=10)
else:
top_posters = None
data = {"group_stat": group_stat, "top_posters": top_posters}
data = self.update_data(data)
return render_to_response(self.get_page_template(), data, RequestContext(self.request))
class ViewTopPosters(BaseGroupAction):
AJAX_URL_NAME = "friday.view_top_posters"
AJAX_TEMPLATE = "poststats/common/top_posters.html"
def get_ajax(self):
group_stat = GroupStat.get_unique(group=self.get_group(), date=datetime.date.today())
if group_stat is not None:
top_posters = PosterStat.find_by_group_stat(group_stat=group_stat, limit=3)
else:
top_posters = None
return {"group_stat": group_stat, "top_posters": top_posters}
#---------------------------------------------------------------------------------------------------
def view_group_stat(request, group_uid, year=None, month=None):
return ViewGroupStat(request, group_uid, year, month).process()
def view_top_posters(request, group_uid):
return ViewTopPosters(request, group_uid).process()
# EOF
| zzheng | friday/website/friday/apps/poststats/views.py | Python | asf20 | 2,256 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-02-15.
# $Id$
#
import logging
from google.appengine.ext import db
from djangomockup import models
from djangomockup.models.signals import pre_delete
from friday.auth import users
class Comment(models.Model):
# The reference object on which this comment was posted. A comment can be attached to any
# object in the datastore. The object is identified by its type (the model class name) and its
# primary key.
ref_type = db.StringProperty(required=True)
ref_pk = db.StringProperty(required=True)
# The content of the comment.
content = db.TextProperty(required=True)
# Metadata about the comment.
author = db.ReferenceProperty(users.User, required=True)
submit_date = db.DateTimeProperty(auto_now_add=True)
schema_version = db.IntegerProperty(required=True, default=1)
@classmethod
def create(cls, ref_type, ref_pk, **kwargs):
return cls(ref_type=ref_type, ref_pk=str(ref_pk), **kwargs)
@classmethod
def find(cls, ref_type, ref_pk, **kwargs):
query = cls.objects.filter(ref_type=ref_type, ref_pk=str(ref_pk)).order_by("-submit_date")
if kwargs.get("limit"):
query.set_limit(kwargs["limit"])
return query
@classmethod
def find_recent(cls, ref_type, **kwargs):
query = cls.objects.filter(ref_type=ref_type).order_by("-submit_date")
if kwargs.get("limit"):
query.set_limit(kwargs["limit"])
return query
@classmethod
def delete_related(cls, ref_type, ref_pk):
deleted = 0
query = cls.objects.filter(ref_type=ref_type, ref_pk=str(ref_pk))
for instance in query:
instance.delete()
deleted += 1
return deleted
#---------------------------------------------------------------------------------------------------
def delete_related_comments(sender, **kwargs):
if sender != Comment:
try:
instance = kwargs["instance"]
deleted = Comment.delete_related(ref_type=sender.__name__, ref_pk=instance.pk)
if deleted > 0:
logging.info("%s related comments have been deleted successfully." % deleted)
except Exception, exc:
logging.error("Failed to delete related comments on instance: %s" % exc)
logging.exception(exc)
pre_delete.connect(delete_related_comments)
# EOF
| zzheng | friday/website/friday/apps/comments/models.py | Python | asf20 | 2,586 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-02-15.
# $Id$
#
from django import forms
from friday.common.errors import ProgrammingError, InvalidFormError
from friday.apps.comments.models import Comment
class CommentForm(forms.Form):
content = forms.CharField(required=True, widget=forms.Textarea)
def __init__(self, data=None, instance=None):
self._instance = instance
if instance:
initial = {"content": instance.content}
else:
initial = None
super(CommentForm, self).__init__(data=data, initial=initial)
def clean_content(self):
content = self.cleaned_data["content"].strip()
if not content:
message = "Comment content cannot be empty."
raise forms.ValidationError(message)
return content
def create(self, ref_type, ref_pk, author):
if self._instance is not None:
message = "Failed to create comment: this form is bound to an existing comment."
raise ProgrammingError(message)
if not self.is_valid():
raise InvalidFormError(self.errors)
instance = Comment.create(
ref_type=ref_type,
ref_pk=ref_pk,
author=author,
**self.cleaned_data
)
instance.save()
return instance
| zzheng | friday/website/friday/apps/comments/forms.py | Python | asf20 | 1,461 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-02-15.
# $Id$
#
from django.conf.urls.defaults import *
from friday.apps.comments.views import *
urlpatterns = patterns("",
url(
r"^(?P<ref_type>[\w\.\-]+)/(?P<ref_pk>[\w\.\-]+)/$",
view_comments,
name="friday.view_comments"
),
)
# EOF
| zzheng | friday/website/friday/apps/comments/urls.py | Python | asf20 | 424 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-02-15.
# $Id$
#
| zzheng | friday/website/friday/apps/comments/__init__.py | Python | asf20 | 150 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-02-15.
# $Id$
#
import logging
from django.http import HttpRequest, HttpResponse, HttpResponseRedirect
from django.template import RequestContext
from django.shortcuts import render_to_response
from django.core.urlresolvers import reverse
from friday.common.errors import BadRequestError, InvalidFormError
from friday.common.prompt import Prompt
from friday.common.actions import Action
from friday.apps.comments.models import Comment
from friday.apps.comments.forms import CommentForm
class BaseCommentsAction(Action):
def __init__(self, request, ref_type, ref_pk):
super(BaseCommentsAction, self).__init__(request)
self.ref_type = ref_type
self.ref_pk = ref_pk
def update_data(self, data):
data["ref_type"] = self.ref_type
data["ref_pk"] = self.ref_pk
return super(BaseCommentsAction, self).update_data(data)
class ViewComments(BaseCommentsAction):
AJAX_URL_NAME = "friday.view_comments"
AJAX_TEMPLATE = "comments/common/comments.html"
def update_data(self, data):
comments = Comment.find(ref_type=self.ref_type, ref_pk=self.ref_pk)
data["comments"] = comments
return super(ViewComments, self).update_data(data)
def get_ajax(self):
if self.current_user:
comment_form = CommentForm()
else:
comment_form = None
return {"comment_form": comment_form}
def post_ajax(self):
if not self.current_user:
message = "Anonymous user cannot add comment"
raise BadRequestError(self.request, message)
comment_form = CommentForm(data=self.request.POST)
try:
comment = comment_form.create(
ref_type=self.ref_type,
ref_pk=self.ref_pk,
author=self.current_user
)
return {"comment_form": CommentForm()}
except Exception, exc:
message = "Failed to add comment: %s" % exc
logging.error(message)
logging.exception(exc)
return {"ajax_prompt": Prompt(error=message), "comment_form": comment_form}
#---------------------------------------------------------------------------------------------------
def view_comments(request, ref_type, ref_pk):
return ViewComments(request, ref_type, ref_pk).process()
# EOF
| zzheng | friday/website/friday/apps/comments/views.py | Python | asf20 | 2,548 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2010 ZHENG Zhong <http://www.zhengzhong.net/>
#
# Created on 2010-04-28.
# $Id$
#
import datetime
import logging
from google.appengine.ext import db
from djangomockup import models
from djangomockup import mail
from friday.auth import users
from friday.apps.notifications.signals import something_happened
class Notification(models.Model):
_RESERVED_KEYS = ("create",)
category = db.StringProperty(required=True)
subject = db.StringProperty(required=True)
message = db.TextProperty(required=True)
author = db.ReferenceProperty(users.User, required=True)
recipients = db.ListProperty(db.Email, required=True, default=[])
send_date = db.DateTimeProperty(required=False)
schema_version = db.IntegerProperty(required=True, default=1)
def __unicode__(self):
return unicode(self.subject)
@classmethod
def get_unique(cls, id):
try:
instance = cls.objects.get(id=id)
except cls.DoesNotExist:
instance = None
return instance
@classmethod
def create(cls, **kwargs):
# Convert recipients string list to a list of db.Email objects.
recipients = []
for recipient_email in kwargs["recipients"]:
if mail.is_email_valid(recipient_email):
recipients.append(db.Email(recipient_email))
else:
logging.warning("Invalid email address ignored: %s" % recipient_email)
kwargs["recipients"] = recipients
# Create an instance.
return cls(**kwargs)
@classmethod
def send(cls, **kwargs):
notification = cls.create(**kwargs)
mail.send_mail(
subject=notification.subject,
message=notification.message,
from_email=notification.author.email,
recipient_list=notification.recipients
)
notification.send_date = datetime.datetime.now()
notification.save()
return notification
@classmethod
def find(cls, **kwargs):
query = cls.objects.all()
if "category" in kwargs:
query = query.filter(category=kwargs["category"])
if "author" in kwargs:
query = query.filter(author=kwargs["author"])
if "recipient" in kwargs:
query = query.filter(recipients=db.Email(kwargs["recipient"]))
query = query.order_by(kwargs.get("order_by") or "-send_date")
if kwargs.get("limit"):
query.set_limit(kwargs["limit"])
return query
def send_notification(sender, **kwargs):
try:
kwargs["message"] = kwargs["message"].strip()
subject = kwargs.get("subject") or kwargs["message"].splitlines()[0]
Notification.send(
category=unicode(sender),
subject=subject,
message=kwargs["message"],
author=kwargs["author"],
recipients=kwargs["recipients"]
)
except Exception, exc:
logging.error("Failed to send notification: %s" % exc)
logging.exception(exc)
something_happened.connect(send_notification)
# EOF
| zzheng | friday/website/friday/apps/notifications/models.py | Python | asf20 | 3,259 |