def get(self, **kwargs):
try:
id = kwargs.pop("requisition.id")
transaction.manager:
return DBSession.query(Requisition).get(id).first()
except KeyError as err:
return DBSession.query(Requisition).filter(voided = False)
def _update():
if _is_valid(j_user):
user = get({"user_id": self.id})
user = _set_user(user)
with transaction.manager:
DBSession.merge(user)
transaction.commit()
def _update():
purchase_order_id = self.id
purchase_order = _set_purchase_order(get({"id": purchase_order_id}))
with transaction.manager:
DBSession.merge(purchase_order)
transaction.commit()
def _create():
errors = {} #list of data entry errors
if self.username is None or self.first_name is None or self.last_name is None:
if self.username is None:
errors["username"] = "******"
elif self.first_name is None:
errors["first_name"] = "No First Name"
else:
errors["last_name"] = "No Last Name"
return errors
if self.username is None:
raise ValueError("username was not supplied")
elif self.first_name is None:
raise ValueError("first name not entered")
elif self.last_name is None:
raise ValueError("last name not entered")
user = User(self.username, self.first_name, self.last_name)
user = _set_user(user)
if _is_valid(user):
try:
user.password = sha256_digest(password)
except ValueError as err:
print err.message
raise ValueError("No password supplied")
with transaction.manager:
DBSession.add(user)
else:
print "Invalid user"
def delete_branch(self, j_branch):
branch_id = j_branch.pop("suppliers_branch_id", None)
if not branch_id:
raise KeyError("Invalid Branch")
branch = DBSession.query(SupplierBranch).get(branch_id)
with transaction.manager:
DBSession.delete(branch)
def _update():
department = self.get(self.id)
department = self._set_department(department)
with transaction.manager:
DBSession.merge(department)
transaction.commit()
def _create():
requisition = Requisition()
requisition = _set_requisition(requisition)
with transaction.manager:
DBSession.add(requisition)
transaction.commit()
def delete(self, requisition_id):
requisition = get(requisition_id)
requisition.void = True
with transaction.manager:
DBSession.merge(requisition)
transaction.commit()
def get(self, **kwargs):
"""
Retrieve a user or list of users depending on the arguments passed
to the function
"""
#Determine if user is searching by id or username
user_id = kwargs.pop("user_id", None)
username = kwargs.pop("username", None)
try:
print user_id
user_id = int(user_id)
except TypeError or ValueError: user_id = 0
if username is None and user_id == 0:
print "USERNAME IS NONW AND USERID = 0"
return self._all()
elif user_id > 0 and username is None:
print "USERNAME IS NONW AND USERID = 0"
return DBSession.query(User).get(user_id)
elif user_id == 0 and username is not None:
print "USERNAME IS NOT NONE AND USERID = 0"
if len(username) == 0:
raise ValueError("Illegal username entered")
users = DBSession.query(User). \
filter(or_(User.username.like('%' + username + '%'),\
User.fullname.like('%' + username + '%'))).all()
return users
elif user_id > 0 and username is not None:
print "BOTH ARE FILLED INUSERNAME IS NOT NONE AND USERID = 0"
users = DBSession.query(User).filter( \
or_(User.id == user_id,\
User.username.like('%' + username + '%'))).all()
return
def get(self, **kwargs):
try:
department_id = kwargs.pop("department.id")
return DBSession.query(Department).get(int(department_id)).first()
except KeyError as err:
print err
return DBSession.query(Department).all()
return None
def delete(self, j_department):
_set_attributes(j_department)
department = get(self.id)
department.void = True
with transaction.manager:
DBSession.merge(department)
transaction.commit()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
engine = engine_from_config(settings, "sqlalchemy.")
DBSession.configure(bind=engine)
authn_policy = AuthTktAuthenticationPolicy("sosecret", callback=groupfinder)
authz_policy = ACLAuthorizationPolicy()
set_cache_regions_from_settings(settings)
config = Configurator(settings=settings, root_factory="scm.models.RootFactory")
config.set_authentication_policy(authn_policy)
config.set_authorization_policy(authz_policy)
# config.add_static_view('static', 'static', cache_max_age=3600)
# config.add_route('home', '/')
# config.scan()
# return config.make_wsgi_app()
config.add_view("scm.views.suppliers", name="supplier", renderer="json")
config.add_static_view("static", "static", cache_max_age=3600)
# config.add_static_view(name='static', path='/var/www/static', cache_max_age=3600)
config.add_route("login", "/login")
config.add_route("logout", "/logout")
config.add_route("home", "/")
config.add_route("proc", "/proc/")
config.add_route("modem_page", "/modem/")
###finance
config.add_route("banks_page", "/banks/")
# procurement
config.add_route("purchase_orders_page", "/purchase_orders/")
config.add_route("requisitions_page", "/requisitions/")
config.add_route("departments_page", "/departments/")
config.add_route("suppliers_page", "/suppliers/")
config.add_route("store_issues_page", "/store_issues/")
config.add_route("delivery_note_page", "/delivery_note/")
config.add_route("goods_received_page", "/goods_received/")
config.add_route("goods_returned_page", "/goods_returned/")
config.add_route("users_page", "/users/")
config.add_route("bincard_page", "/bincard/")
config.add_route("purchase_orders_by_status_page", "/purchase_orders_by_status/")
config.add_route("purchase_orders_by_supplier_page", "/purchase_orders_by_supplier/")
config.add_route("store_issues_report_page", "/store_issues_report/")
config.add_route("goods_received_report_page", "/goods_received_report/")
config.add_route("goods_returned_report_page", "/goods_returned_report/")
config.add_route("permissions", "/permissions/")
#######controller operations###############################################
config.add_route("supplier_controller", "/supplier/operations")
####admin###################
config.add_route("user_controller", "/users/operations")
config.scan()
return config.make_wsgi_app()
def _create():
supplier = DBSession.query(Supplier).get(supplier_id)
print supplier.to_dict
if supplier is None:
raise TypeError("Could not find supplier with id: %s" % supplier_id)
branch = SupplierBranch(supplier_id)
branch = _setattr(branch)
del branch.id
with transaction.manager:
DBSession.add(branch)
def get(self, *args, **kwargs):
department_id = 0
if len(args):
department_id = args[0]
return DBSession.query(Department).get(int(department_id))
elif not len(args) and not len(kwargs):
return DBSession.query(Department).\
filter(Department.voided == False).all()
return False
def index(self, class_name):
if isinstance(class_name, User):
with transaction.manager:
users = [user.id for user in DBSession.query(User).all()]
#rint [("User: %s class: %s") % (user.serialize, class_name.serialize) for user in users if user == class_name]
return users.index(class_name.id)
elif isinstance(class_name, Permission):
with transaction.manager:
permissions = DBSession.query(Permission).all()
return permissions.index(class_name)
return -1
def delete(self, supplier):
"""
Mark a Supplier as deleted.
The database delete operation occurs upon flush().
"""
supplier = DBSession.query(Supplier).get(supplier.id)
if not supplier:
raise ValueError("Did not find Supplier")
if _validate(supplier):
with transaction.manager:
DBSession.delete(supplier)
return True
def delete(self, j_group):
try:
name = j_group.pop("group.name")
self.id = j_group.pop("group.id")
except KeyError as err:
print err
raise KeyError()
with transaction.manager:
group = DBSession.query(Group).get(self.id)
#Complete deletion may not be the best option. An alternative -
#option is to void the instance
#DBSession.delete(group)
group.void = True
DBSession.merge(group)
transaction.commit()
def _create():
"""
Create a new Group
"""
group = Group(name)
group.created_by = User.get_by_username(created_by)
group.modified_by = User.get_by_username(modified_by)
group.created_by = group.created_by.id
group.modified_by = group.modified_by.id
created_date = datetime.now()
group.created_date = created_date
group.modified_date = created_date
with transaction.manager:
DBSession.add(group)
transaction.commit()
def _update():
"""
Update an existing Group
"""
try:
self.id = j_group.pop("group.id")
self.name = j_group.pop("group.name")
except KeyError as err:
print err
raise KeyError
with transaction.manager:
group = DBSession.query(Group).get(self.id)
if group is None:
raise ValueError("Group not found")
group.name = self.name
group.modified_by = self.modified_by
group.modified_date = self.now
DBSession.merge(group)
transaction.commit()
def get(self, **kwargs):
"""
Copy the state an instance onto the persistent instance with the same
identifier.
If there is no persistent instance currently associated with the
session, it will be loaded. Return the persistent instance. If the
given instance is unsaved, save a copy of and return it as a newly
persistent instance. The given instance does not become associated
with the session.
"""
supplier_id = kwargs.pop(self.supplier_id_key, None)
supplier_name = kwargs.pop(self.supplier_name_key, None)
suppliers = None
if supplier_id and not supplier_name:
try:
supplier_id = int(supplier_id)
except TypeError:
raise TypeError("Invalid Supplier Id submitted")
return self._all()
elif supplier_name:
return DBSession.query(Supplier).filter(Supplier.name.like("%" + supplier_name + "%")).all()
elif not supplier_id and not supplier_name:
return self._all()
return None
def _create():
with transaction.manager:
supplier.created_by = user.id
supplier.modified_by = user.id
DBSession.add(supplier)
region_invalidate(_all, "hour")
def _update():
with transaction.manager:
requisition = DBSession.get(requisition.id)
requisition = _set_requisition(requisition)
DBSession.merge(requisition)
transaction.commit()
def _all(self):
with transaction.manager:
return DBSession.query(Permission). \
order_by(Permission.id).all()
def _update():
branch = DBSession.query(SupplierBranch).get(branch_id)
branch = _setattr(branch)
with transaction.manager:
DBSession.merge(branch)
def _create():
department = _set_department(Department())
with transaction.manager:
DBSession.add(department)
transaction.commit()
def _update():
item = DBSession.query(Item).get(item_id)
_setattr(item)
with transaction.manager:
DBSession.merge(item)
return True
def _create():
purchase_order = _set_purchase_order(LocalPurchaseOrder())
with transaction.manager:
DBSession.add(purchase_order)
transaction.commit()
def _all(self):
"""
Return all suppliers
"""
users = DBSession.query(Supplier).order_by(Supplier.id).options(joinedload("branches")).all() or None
return users
def permissions(request):
permissions = DBSession.query(Permission).all()
for permission in permissions:
print ("%s %s %s") % (permission.id, permission.name, permission.description)
return permissions
def _update():
with transaction.manager:
supplier.modified_by = user.id
DBSession.merge(supplier)
region_invalidate(_add)
