def cancel_activity():
session = Session()
session.expire_on_commit = False
_id = request.args.get('id')
record = session.query(Activity).filter_by(id=_id).first()
if not record:
return jsonify(result={'res': False,'Error':'Registro no Encontrado'})
record.setOldFields()
record.Status = record.CANCELLED
res = record.check()
if not res:
return jsonify(result={'res': False,'Error':str(res)})
record.syncVersion += 1
res = record.afterUpdate()
if not res:
return jsonify(result={'res': False,'Error':str(res)})
try:
session.commit()
session.close()
except Exception as e:
session.rollback()
session.close()
return jsonify(result={'res': False,'Error':str(e)})
record.callAfterCommitUpdate()
return jsonify(result={'res':True,'id': record.id,'syncVersion': record.syncVersion})
def updateRecord(TableClass,fields):
getDetailDict(fields)
session = Session()
session.expire_on_commit = False
record = session.query(TableClass).filter_by(id=fields['id']).first()
if not record:
return jsonify(result={'res': False, 'Error': 'Registro no Encontrado'})
if not record.checkSyncVersion(fields.get('syncVersion', None)):
return jsonify(result={'res': False, 'Error': 'Otro Usuario ha modoficado el Registro'})
record.fromJSON(fields)
res = record.check()
if not res:
return jsonify(result={'res': False, 'Error': str(res)})
record.syncVersion += 1
res = record.afterUpdate()
if not res:
return jsonify(result={'res': False, 'Error': str(res)})
try:
session.commit()
except Exception as e:
session.rollback()
session.close()
return jsonify(result={'res': False, 'Error': str(e)})
record.callAfterCommitUpdate()
session.close()
RunJS = record.afterSaveJS()
return jsonify(result={'res': True, 'record': record.toJSON(), 'RunJS': RunJS})
def getEventList(cls,
UserId=None,
CompanyId=None,
limit=None,
order_by=None,
desc=None):
UserProf = aliased(User)
session = Session()
records = session.query(cls) \
.filter(or_(cls.Type==1,cls.Type==2)) \
.join(ActivitySchedules,cls.id==ActivitySchedules.activity_id)\
.filter(ActivitySchedules.TransDate>=today()) \
.join(Company,cls.CompanyId==Company.id)\
.join(UserProf,cls.ProfId==UserProf.id)\
.outerjoin(Service,cls.ServiceId==Service.id)\
.with_entities(cls.Comment,UserProf.Name.label('ProfId') \
,ActivitySchedules.TransDate \
,ActivitySchedules.StartTime \
,ActivitySchedules.EndTime,cls.id,cls.Status,Company.Name.label('CompanyId')\
,Service.Name.label('ServiceId'))
if UserId:
records = records.filter(cls.ProfId == UserId)
if CompanyId:
records = records.filter(cls.CompanyId == CompanyId)
if order_by and desc:
records = records.order_by(ActivitySchedules.TransDate.desc())
elif order_by:
records = records.order_by(ActivitySchedules.TransDate)
else:
records = records.order_by(ActivitySchedules.TransDate)
if limit: records = records.limit(limit)
session.close()
return records
def getRecordList(cls, TableClass, limit=None, order_by=None, desc=None):
session = Session()
records = session.query(cls)
if current_user.UserType == 1:
records = records.filter_by(CompanyId=current_user.CompanyId)
session.close()
return records
def addNewUser(cls,email,password,name):
session = Session()
new_user = User(Password=password)
new_user.syncVersion = 0
new_user.UserType = 3
new_user.Closed = 0
new_user.NtfActivityConfirm = 1
new_user.NtfActivityCancel = 1
new_user.NtfActivityChange = 1
new_user.NtfActivityNew = 1
new_user.Name = name
new_user.Email = email
new_user.CreatedDate = today()
session.add(new_user)
try:
session.commit()
from tools.MailTools import sendNewUserMail
sendNewUserMail(email,name,password)
except Exception as e:
session.rollback()
session.close()
return Error(str(e))
user = session.query(User).filter_by(Email=email).first()
session.close()
if user:
return User(user.id,user.Password,user.Active,user.UserType,user.CompanyId)
def saveNewRecord(TableClass,fields):
del fields['id']
new_record = TableClass()
getDetailDict(fields)
session = Session()
session.expire_on_commit = False
new_record.fromJSON(fields)
if not new_record.beforeInsert():
return jsonify(result={'res': False, 'Error': 'Error en Campos'})
res = new_record.check()
if not res:
return jsonify(result={'res': False, 'Error': str(res)})
session.add(new_record)
res = new_record.afterInsert()
if not res:
return jsonify(result={'res': False, 'Error': str(res)})
try:
session.commit()
except Exception as e:
session.rollback()
session.close()
return jsonify(result={'res': False, 'Error': str(e)})
new_record.callAfterCommitInsert()
RunJS = new_record.afterSaveJS()
session.close()
return jsonify(result={'res': True, 'record': new_record.toJSON(), 'RunJS': RunJS})
def set_payment():
from db.Payment import Payment
activityId = request.args.get('activityId')
session = Session()
record = session.query(Activity).filter_by(id=activityId).first()
companyId = record.CompanyId
session.close()
session = Session()
session.expire_on_commit = False
record = Payment()
record.UserId = current_user.id
record.CompanyId = companyId
record.ActivityId = activityId
record.ResponseCode = request.args.get('x_cod_response')
record.Response = request.args.get('x_response')
record.Amount = request.args.get('x_amount')
record.TransDate = now()
record.Reference = request.args.get('x_id_invoice')
record.Reason = request.args.get('x_response_reason_text')
record.TransactionId = request.args.get('x_transaction_id')
record.BankName = request.args.get('x_bank_name')
record.AutorizationCode = request.args.get('x_approval_code')
record.Currency = request.args.get('x_currency_code')
record.beforeInsert()
session.add(record)
res = record.save(session)
if res:
return jsonify(result={'res':True,'id':record.id})
else:
return jsonify(result={'res':False,'Error':str(res)})
def getRecordList(cls,TableClass,limit=None,order_by=None,desc=None):
session = Session()
records = session.query(TableClass)
if order_by and desc: records = records.order_by(TableClass.c[order_by].desc())
elif order_by: records = records.order_by(TableClass.c[order_by])
if limit: records = records.limit(limit)
session.close()
return records
def getUserIdByEmail(cls,email):
session = Session()
record = session.query(cls).filter_by(Email=email).first()
if not record:
return
id = record.id
session.close()
return id
def getLinksTo(self, record_list):
res = {}
res['CompanyId'] = {}
session = Session()
records = session.query(Company)
for record in records:
res['CompanyId'][record.id] = [record.Name, 0]
session.close()
return res
def getFavorite(self):
from db.UserFavorite import UserFavorite
session = Session()
record = session.query(UserFavorite).filter_by(UserId=current_user.id,FavoriteId=self.id).first()
if record and record.Checked:
session.close()
return 1
session.close()
return 0
def getRecordList(cls,TableClass,limit=None,order_by=None,desc=None):
session = Session()
records = session.query(cls)
if current_user.UserType==1:
records = records.filter(cls.CompanyId==current_user.CompanyId,cls.UserType>=1)
elif current_user.UserType==2:
records = records.filter(cls.CompanyId==current_user.CompanyId, \
or_(cls.UserType==3,cls.id==current_user.id))
session.close()
return records
def getUserService(params):
session = Session()
from db.UserService import UserService
from db.Service import Service
records = session.query(UserService)\
.join(User,User.id==UserService.UserId)\
.join(Service,Service.id==UserService.ServiceId)\
.filter_by(CompanyId=current_user.CompanyId) \
.with_entities(UserService.id,UserService.CompanyId,User.Name.label("UserName"),Service.Name.label("ServiceName"))
session.close()
return records
def get_service_price():
ServiceId = request.args.get('ServiceId')
session = Session()
record = session.query(Service).filter_by(id=ServiceId).first()
price = None
if record and record.Price:
price = record.Price
session.close()
if price:
return jsonify(result=str(price))
else:
return jsonify(result=None)
def getOverlapHeader(self, UserId, TransDate, StartTime, EndTime,
ActivityUser):
session = Session()
records = session.query(Activity) \
.filter(Activity.Status!=2,ActivityUser==UserId,Activity.id!=self.id) \
.join(ActivitySchedules,Activity.id==ActivitySchedules.activity_id)\
.filter(ActivitySchedules.TransDate==TransDate,~ or_(ActivitySchedules.EndTime<=StartTime,ActivitySchedules.StartTime>=EndTime)) \
.join(User,ActivityUser==User.id)\
.with_entities(User.Name,ActivitySchedules.TransDate,ActivitySchedules.StartTime \
,ActivitySchedules.EndTime,Activity.id,Activity.Status)
session.close()
if records.count() > 0:
return True
return False
def getRecordList(cls, TableClass, limit=None, order_by=None, desc=None):
session = Session()
records = session.query(TableClass)
if current_user.UserType == 1:
records = records.filter_by(CompanyId=current_user.CompanyId)
elif current_user.UserType == 3:
records = records.filter_by(UserId=current_user.id)
if order_by and desc:
records = records.order_by(TableClass.c[order_by].desc())
elif order_by:
records = records.order_by(TableClass.c[order_by])
if limit: records = records.limit(limit)
session.close()
return records
def getRecordList(cls, TableClass, limit=None, order_by=None, desc=None):
if current_user.UserType == (1, 2):
session = Session()
records = session.query(TableClass).filter_by(
CompanyId=current_user.CompanyId)
session.close()
elif current_user.UserType == 1:
session = Session()
records = session.query(TableClass).filter_by(
CompanyId=current_user.CompanyId)
session.close()
else:
records = Record.getRecordList(TableClass)
return records
def run(cls, filters):
fd = filters['FromDate'].split('-')
td = filters['ToDate'].split('-')
FromDate = date(int(fd[0]), int(fd[1]), int(fd[2]))
ToDate = date(int(td[0]), int(td[1]), int(td[2]))
session = Session()
records = session.query(func.concat(func.year(User.CreatedDate),'-',func.month(User.CreatedDate)), func.count(User.CreatedDate).label('CNT'))\
.filter(User.CreatedDate.between(FromDate,ToDate))\
.group_by(func.concat(func.year(User.CreatedDate),'-',func.month(User.CreatedDate)))\
.order_by(func.concat(func.year(User.CreatedDate),'-',func.month(User.CreatedDate)).desc())\
.all()
session.close()
columns = ['Mes', 'Cantidad']
return {'Columns': columns, 'Rows': records}
def addNewUser(cls,username,password):
from sqlalchemy.orm import sessionmaker
session = Session()
new_user = User(username,password,0,None)
new_user.syncVersion = 0
new_user.UserType = 3
session.add(new_user)
try:
session.commit()
except:
session.rollback()
user = session.query(User).filter_by(id=username).first()
session.close()
if user:
return User(user.id,user.Password,user.Active,user.UserType)
def getLinkToFromRecord(self, TableClass):
if TableClass == Service:
session = Session()
if self.ProfId:
records = session.query(UserService)\
.filter_by(UserId=self.ProfId)\
.join(Service,UserService.ServiceId==Service.id)\
.with_entities(Service.id,Service.Name)
else:
records = session.query(UserService).join(Service,UserService.ServiceId==Service.id)\
.filter_by(CompanyId=self.CompanyId)\
.with_entities(Service.id,Service.Name)
session.close()
return records
else:
return TableClass.getRecordList(TableClass)
def getRecordList(cls,
TableClass,
custId=None,
limit=None,
order_by=None,
desc=None,
ProfId=None,
Alias=False):
if Alias:
UserProf = aliased(User)
UserCust = aliased(User)
session = Session()
records = session.query(cls)
if current_user.UserType == 3:
records = records.filter_by(CustId=current_user.id)
if custId and current_user.UserType in (1, 2):
records = records.filter_by(CompanyId=current_user.CompanyId,
CustId=custId)
if current_user.UserType == 2:
records = records.filter_by(ProfId=current_user.id)
records = records.join(ActivitySchedules,cls.id==ActivitySchedules.activity_id)\
.filter(ActivitySchedules.TransDate>=today())
if Alias:
records = records.join(UserProf,cls.ProfId==UserProf.id)\
.outerjoin(UserCust,cls.CustId==UserCust.id)\
.outerjoin(Service,cls.ServiceId==Service.id)
if current_user.UserType == 0:
records = records.filter(or_(ProfId == None, cls.ProfId == ProfId))
if not Alias:
records = records.with_entities(cls.Comment,cls.ProfId,ActivitySchedules.TransDate,ActivitySchedules.StartTime \
,ActivitySchedules.EndTime,cls.id,cls.Status,cls.CustId,cls.CompanyId,cls.ServiceId,cls.Type)
else:
records = records.with_entities(cls.Comment, UserProf.id.label('ProfId'), ActivitySchedules.TransDate \
,ActivitySchedules.StartTime , ActivitySchedules.EndTime, cls.id, cls.Status, UserCust.id.label('CustId')\
, cls.CompanyId, Service.id.label('ServiceId'), cls.Type, UserCust.Name.label('CustName'))
if not custId and current_user.UserType in (1, 2):
records = records.filter(
Activity.CompanyId == current_user.CompanyId)
if order_by and desc:
records = records.order_by(ActivitySchedules.TransDate.desc())
elif order_by:
records = records.order_by(ActivitySchedules.TransDate)
if limit: records = records.limit(limit)
session.close()
return records
def getLinksTo(self,record_list):
res = {}
res['UserType'] = {self.CUST: ['Cliente',0]}
if current_user.UserType==0:
res['UserType'][self.SUPER] = ['Super',0]
res['UserType'][self.ADMIN] = ['Administrador',0]
res['UserType'][self.PROF] = ['Profesional', 0]
if current_user.UserType==1:
res['UserType'][self.ADMIN] = ['Administrador',0]
res['UserType'][self.PROF] = ['Profesional',0]
res['CompanyId'] = {}
session = Session()
records = session.query(Company)
for record in records:
res['CompanyId'][record.id] = [record.Name,record.Closed]
session.close()
return res
def getProfessional(favorite,companyId):
session = Session()
if not favorite:
records = session.query(User).filter_by(FindMe=True)\
.join(Company,User.CompanyId==Company.id)
if companyId:
records = records.filter(User.CompanyId==companyId)
records = records.with_entities(User.id,User.Name,Company.Name.label("CompanyName"),User.Title,User.City)
else:
from db.UserFavorite import UserFavorite
records = session.query(User)\
.join(UserFavorite,User.id==UserFavorite.FavoriteId)\
.filter_by(UserId=current_user.id,Checked=True)\
.join(Company,User.CompanyId==Company.id)
if companyId:
records = records.filter(User.CompanyId==companyId)
records = records.with_entities(User.id,User.Name,Company.Name.label("CompanyName"),User.Title,User.City)
session.close()
return records
def getRecordList(cls,TableClass,custId=None,limit=None,order_by=None,desc=None):
session = Session()
if current_user.UserType==3:
records = session.query(cls).filter_by(UserId=current_user.id)\
.join(User,User.id==cls.ProfId)\
.with_entities(User.Name,cls.TransDate,cls.Note)\
.order_by(UserNote.TransDate.desc())
elif current_user.UserType in (0,1):
records = session.query(cls).filter_by(CompanyId=current_user.CompanyId,UserId=custId)\
.join(User,User.id==cls.ProfId)\
.with_entities(User.Name,cls.TransDate,cls.Note)\
.order_by(UserNote.TransDate.desc())
elif current_user.UserType==2:
records = session.query(cls).filter_by(CompanyId=current_user.CompanyId,UserId=custId,ProfId=current_user.id)\
.join(User,User.id==cls.ProfId)\
.with_entities(User.Name,cls.TransDate,cls.Note)\
.order_by(UserNote.TransDate.desc())
session.close()
return records
def getLinksTo(self, record_list):
res = {}
res['ServiceId'] = {}
session = Session()
records = session.query(Service)
if current_user.UserType > 0:
records = records.filter_by(CompanyId=current_user.CompanyId)
for record in records:
res['ServiceId'][record.id] = [record.Name, 0]
session.close()
res['UserId'] = {}
records = session.query(User).filter(User.UserType < 3)
if current_user.UserType > 0:
records = records.filter_by(CompanyId=current_user.CompanyId)
for record in records:
res['UserId'][record.id] = [record.Name, 0]
session.close()
return res
def delete_record():
table = request.args.get('TableName')
TableClass = getTableClass(table)
_id = request.args.get('id')
if _id==current_user.id:
return jsonify(result={'res': False, 'Error': 'No se puede borrar usuario actual'})
if _id:
session = Session()
record = session.query(TableClass).filter_by(id=_id).first()
if not record:
return jsonify(result={'res': False, 'Error': 'Registro no encontrado'})
res = session.delete(record)
try:
session.commit()
session.close()
return jsonify(result={'res': True})
except Exception as e:
session.rollback()
session.close()
return jsonify(result={'res': False, 'Error': str(e)})
def getRecordByFilters(table,filters,values):
TableClass = getTableClass(table)
session = Session()
if not filters:
record = TableClass()
record.defaults()
for f in values:
record.__setattr__(f,values[f])
else:
record = session.query(TableClass).filter_by(**filters).first()
if not record:
return {'res':False}
fields = TableClass.getFields()
recordTitle = TableClass.getRecordTitle()
canEdit = TableClass.canUserEdit(record)
canDelete = TableClass.canUserDelete()
events = TableClass.getEvents()
links = TableClass.getLinksTo([record])
res = record.toJSON()
session.close()
return {'record': res, 'fields': fields, 'links': links,'recordTitle':recordTitle,'canEdit':canEdit
, 'canDelete':canDelete, 'events': events}
def getCustomer(args):
favorite = args.get('favorite',None)
session = Session()
if not favorite:
records = session.query(User).filter_by(UserType=3)
else:
from db.UserFavorite import UserFavorite
records1 = session.query(User).filter_by(UserType=3)\
.join(UserFavorite,User.id==UserFavorite.FavoriteId)\
.filter_by(UserId=current_user.id,Checked=True)\
.with_entities(User.id, User.Name,User.Closed,User.UserType)
records2 = session.query(User).filter_by(UserType=3)\
.join(UserFavorite, User.id == UserFavorite.UserId)\
.filter_by(FavoriteId=current_user.id, Checked=True) \
.with_entities(User.id, User.Name,User.Closed,User.UserType)
#records = records1.union_all(records2)
records = records1
session.close()
return records
def change_password():
pwd = request.args['pwd']
if current_user.Password!=pwd:
return jsonify(result={'res': False,'Error':'Es password actual ingresado es incorrecto'})
newpwd = request.args['newpwd']
session = Session()
record = session.query(User).filter_by(id=current_user.id).first()
if not record:
session.close()
return jsonify(result={'res': False,'Error':'Usuario no encotrado'})
else:
record.Password = newpwd
try:
session.commit()
session.close()
return jsonify(result={'res': True})
except Exception as e:
session.rollback()
session.close()
return jsonify(result={'res': False,'Error':str(e)})
return jsonify(result={'res':True,'id':res.id,'syncVersion':res.syncVersion})
def recover_password():
session = Session()
session.expire_on_commit = False
email = request.args['email']
record = session.query(User).filter_by(Email=email).first()
if not record:
return jsonify(result={'res': False,'Error':'No hay usuario registrado para este Email'})
else:
record.Password = passwordRamdom()
try:
session.commit()
from tools.MailTools import sendPasswordRecoverMail
res = sendPasswordRecoverMail(email,record.Password,record.Name)
if res:
session.close()
return jsonify(result={'res': True})
else:
session.close()
return jsonify(result={'res': False,'Error': 'No se pudo enviar el correo'})
except Exception as e:
session.rollback()
session.close()
return jsonify(result={'res': False,'Error':str(e)})
