def AddEducation(TheEducation, ID):
    '''
	描述:添加一条教育信息到数据库
	参数:一条教育信息(字典),用户openid
	返回:成功True,失败False
	'''
    Success = True
    TheStartYear = 0
    TheDepartment = ""
    TheType = ""
    if Success:
        try:
            TheStartYear = int(TheEducation["enrollmentYear"])
            TheDepartment = TheEducation["department"]
            TheType = TheEducation["enrollmentType"]
        except:
            Success = False
    if Success:
        try:
            TheUser = User.objects.get(OpenID=ID)
            Education.objects.create(StartYear=TheStartYear,
                                     Department=TheDepartment,
                                     Type=TheType,
                                     Student=TheUser)
            #如果有数据库中不存在的教育信息,插入
            GlobalFunctions.AddEducationType(TheType)
            GlobalFunctions.AddDepartment(TheDepartment)
        except:
            Success = False
    return Success
def ShowAllMembersAdmin(TheUserID, TheActivityID):
	'''
	描述:查询活动所有成员---管理员
	参数: 用户id,活动id
	返回:第一个是一个字典,里面就一个字典数组participantList,每个字典有人员的Openid,权限,状态,报名和签到时间,失败为空
		 第二个是原因和错误码,如果成功就是空,否则有reason和code
	'''
	Result = {}
	ErrorInfo = {}
	Reason = ""
	Code = 0
	Success = True
	ResultList = []
	if Success:
		try:
			if JudgeValid.JudgeWhetherManager(TheUserID, TheActivityID) != True:
				Success = False
				Reason = "权限不足,需要是管理员或创建者!"
				Code = Constants.ERROR_CODE_LACK_ACCESS
			TheActivity = Activity.objects.get(ID = TheActivityID)
			TheJoinActivityList = JoinInformation.objects.filter(ActivityId = TheActivity)
		except:
			Success = False
			Reason = "未找到活动!"
			Code = Constants.ERROR_CODE_NOT_FOUND
	
	if Success:
		try:
			for item in TheJoinActivityList:
				TheResult = {}
				TheResult["openId"] = item.UserId.OpenID
				TheResult["name"] = item.UserId.Name
				TheResult["avatarUrl"] = GlobalFunctions.GetTrueAvatarUrlUser(item.UserId.AvatarURL)
				TheResult["selfStatus"] = item.Status
				TheResult["selfRole"] = item.Role
				TheResult["point"] = item.UserId.Point
				TheResult["submitTime"] = GlobalFunctions.TimeStampToTimeString(item.SubmitTime)
				if item.JoinTime != Constants.UNDEFINED_NUMBER:
					TheResult["joinTime"] = GlobalFunctions.TimeStampToTimeString(item.JoinTime)
				if item.CheckTime != Constants.UNDEFINED_NUMBER:
					TheResult["checkTime"] = GlobalFunctions.TimeStampToTimeString(item.CheckTime)
				if JudgeValid.JudgeUserStatusJoined(item.Status) == True:
					ResultList.append(TheResult)
		except:
			Success = False
			Reason = "查询活动成员失败!"
			Code = Constants.ERROR_CODE_UNKNOWN
	if Success:
		Result["participantList"] = ResultList
		ErrorInfo = {}
	else:
		Result = {}
		ErrorInfo["reason"] = Reason
		ErrorInfo["code"] = Code
	return Result, ErrorInfo
def ShowSelfActivity(TheUserID):
	'''
	描述:查询自己参与过的所有活动和历史记录
	参数: 自己的OpenID
	返回:第一个是一个字典,里面就一个字典数组activityList,字典每个字典有活动具体信息和自己的情况,失败为空
		 第二个是失败状态信息,成功是空,失败有reason和code
	'''
	Result = {}
	Success = True
	ResultList = []
	ErrorInfo = {}
	Reason = ""
	Code = 0
	if Success:
		try:
			TheUser = User.objects.get(OpenID = TheUserID)
			TheJoinActivityList = JoinInformation.objects.filter(UserId = TheUser)
			TheJoinActivityList = TheJoinActivityList.reverse()
		except:
			Success = False
			Reason = "未找到用户!"
			Code = Constants.ERROR_CODE_NOT_FOUND
	if Success:
		try:
			i = len(TheJoinActivityList) - 1
			while i >= 0:
				item = TheJoinActivityList[i]
				TheResult = {}
				TheResult = ActivityManager.QueryActivity(item.ActivityId.ID)
				if TheResult == {}:
					continue
				TheResult["id"] = item.ActivityId.ID
				TheResult["selfStatus"] = item.Status
				TheResult["selfRole"] = item.Role
				TheResult["submitTime"] = GlobalFunctions.TimeStampToTimeString(item.SubmitTime)
				if item.JoinTime != Constants.UNDEFINED_NUMBER:
					TheResult["joinTime"] = GlobalFunctions.TimeStampToTimeString(item.JoinTime)
				if item.CheckTime != Constants.UNDEFINED_NUMBER:
					TheResult["checkTime"] = GlobalFunctions.TimeStampToTimeString(item.CheckTime)
				ResultList.append(TheResult)
				i -= 1
		except:
			Success = False
			Reason = "查询历史记录失败!"
			Code = Constants.ERROR_CODE_UNKNOWN
	if Success:
		Result["activityList"] = ResultList
		ErrorInfo = {}
	else:
		Result = {}
		ErrorInfo["reason"] = Reason
		ErrorInfo["code"] = Code
	return Result, ErrorInfo
Пример #4
0
def AddCreatorIntoActivity(CreatorID, TheActivityID):
    '''
	描述:将创建者加入活动
	参数:创建者id,活动id
	返回:成功{result:success},失败{result:fail,reason:xxx, code:xxx}
	'''
    Success = True
    Return = {}
    Code = Constants.UNDEFINED_NUMBER
    Reason = ""
    TheSubmitTime = -1
    TheJoinTime = -1
    TheCheckTime = -1
    if Success:
        try:
            TheUser = User.objects.get(OpenID=CreatorID)
            TheActivity = Activity.objects.get(ID=TheActivityID)
        except:
            Success = False
            Reason = "未找到创建者或活动"
            Code = Constants.ERROR_CODE_NOT_FOUND
    if Success:
        try:
            TheSubmitTime = GlobalFunctions.GetCurrentTime()
            TheJoinTime = GlobalFunctions.GetCurrentTime()
            TheCheckTime = GlobalFunctions.GetCurrentTime()
            TheJoinReason = "无"
            TheStatus = Constants.USER_STATUS_CHECKED
            TheRole = Constants.USER_ROLE_CREATOR
            try:
                TheJoinInformation = JoinInformation.objects.get(
                    UserId=TheUser, ActivityId=TheActivity)
                TheJoinInformation.delete()
            except:
                donothing = 0
            TheJoinInformation = JoinInformation.objects.create(UserId = TheUser, ActivityId = TheActivity, Status = TheStatus,\
            Role = TheRole, SubmitTime = TheSubmitTime, JoinTime = TheJoinTime, CheckTime = TheCheckTime, JoinReason = TheJoinReason)
            TheJoinInformation.save()
            TheActivity.CurrentUser = TheActivity.CurrentUser + 1
            TheActivity.save()
        except:
            Success = False
            Reason = "将创建者加入活动失败"
            Code = Constants.ERROR_CODE_UNKNOWN
    if Success:
        Return["result"] = "success"
    else:
        Return["result"] = "fail"
        Return["reason"] = Reason
        Return["code"] = Code
    return Return
Пример #5
0
def UploadActivityQRCode(TheUserID, TheActivityID):
    '''
	描述:上传活动二维码
	参数:用户openid,活动id
	返回:结果,图片文件名(失败是None)
	'''
    Success = True
    Result = {}
    Reason = ""
    TheImageName = ""
    Code = Constants.UNDEFINED_NUMBER
    print(TheUserID, TheActivityID)
    if Success:
        try:
            TheUser = User.objects.get(OpenID=TheUserID)
            TheActivity = Activity.objects.get(ID=TheActivityID)
            if JudgeValid.JudgeWhetherManager(TheUserID,
                                              TheActivityID) != True:
                Success = False
                Reason = "没有权限,只有管理员才能设置活动二维码!!"
                Code = Constants.ERROR_CODE_LACK_ACCESS
        except:
            Success = False
            Code = Constants.ERROR_CODE_NOT_FOUND
            Reason = "未找到该活动!"
    print(Success)
    if Success:
        if JudgeValid.JudgeActivityNormal(TheActivityID) != True:
            Success = False
            Reason = "活动状态为异常或结束,不能操作!"
            Code = Constants.ERROR_CODE_INVALID_CHANGE
    if Success:
        TheNewCode = GlobalFunctions.GenerateActivityCode()
        TheActivity.Code = TheNewCode
        TheActivity.save()
        TheImageName = GlobalFunctions.GenerateQRCode(TheActivityID,
                                                      TheNewCode)
    if Success == True:
        Result["result"] = "success"
    else:
        Result["result"] = "fail"
        Result["reason"] = Reason
        Result["code"] = Code
        TheImageName = None
    return Result, TheImageName
def ChangeActivityStatusByTime():
    '''
	描述:根据时间修改所有活动数据
	参数: 无
	返回:成功True, 失败False
	'''
    Success = True
    if Success:
        try:
            Info = Activity.objects.all()
        except:
            Success = False
    if Success:
        try:
            for item in Info:
                if item.StatusGlobal != Constants.ACTIVITY_STATUS_GLOBAL_NORMAL:
                    continue
                TheCurrentTime = GlobalFunctions.GetCurrentTime()
                TheJoinStartTime = item.SignUpStartTime
                TheJoinEndTime = item.SignUpEndTime
                TheCheckStartTime = item.StartTime
                TheCheckEndTime = item.EndTime
                TheCurrentUser = item.CurrentUser
                TheMinUser = item.MinUser
                if item.StatusJoin == Constants.ACTIVITY_STATUS_JOIN_BEFORE:
                    if GlobalFunctions.JudgeWhetherSameMinute(
                            TheJoinStartTime):
                        item.StatusJoin = Constants.ACTIVITY_STATUS_JOIN_CONTINUE
                if item.StatusJoin != Constants.ACTIVITY_STATUS_JOIN_STOPPED:
                    if GlobalFunctions.JudgeWhetherSameMinute(TheJoinEndTime):
                        item.StatusJoin = Constants.ACTIVITY_STATUS_JOIN_STOPPED
                if item.StatusCheck == Constants.ACTIVITY_STATUS_CHECK_BEFORE:
                    if GlobalFunctions.JudgeWhetherSameMinute(
                            TheCheckStartTime
                    ) and TheCurrentUser >= TheMinUser:
                        item.StatusCheck = Constants.ACTIVITY_STATUS_CHECK_CONTINUE
                if item.StatusCheck != Constants.ACTIVITY_STATUS_CHECK_STOPPED:
                    if GlobalFunctions.JudgeWhetherSameMinute(TheCheckEndTime):
                        item.StatusCheck = Constants.ACTIVITY_STATUS_CHECK_STOPPED
                item.save()
        except:
            Success = False
    return Success
def ChangeActivityStatusFinish():
    '''
	描述:根据时间(23:59)修改所有当天结束的活动为finish,并且修改成员状态
	参数: 无
	返回:成功True, 失败False
	'''
    Success = True
    if GlobalFunctions.JudgeWhetherDayEnd() != True:
        return True
    if Success:
        try:
            Info = Activity.objects.all()
        except:
            Success = False
    if Success:
        try:
            for item in Info:
                if item.StatusGlobal != Constants.ACTIVITY_STATUS_GLOBAL_NORMAL:
                    continue
                TheCheckEndTime = item.EndTime
                if GlobalFunctions.JudgeWhetherSameDay(
                        TheCheckEndTime) != True:
                    continue
                item.StatusGlobal = Constants.ACTIVITY_STATUS_GLOBAL_FINISH
                item.save()
                TheJoinActivityList = JoinInformation.objects.filter(
                    ActivityId=item)
                for one in TheJoinActivityList:
                    if one.Status == Constants.USER_STATUS_WAITVALIDATE:
                        one.Status = Constants.USER_STATUS_REFUSED
                    elif one.Status == Constants.USER_STATUS_JOINED:
                        one.Status = Constants.USER_STATUS_FINISHED_WITHOUT_CHECK
                    elif one.Status == Constants.USER_STATUS_CHECKED:
                        one.Status = Constants.USER_STATUS_FINISHED
                        if one.Role == Constants.USER_ROLE_CREATOR:
                            one.UserId.Point += Constants.SUCCESS_GET_POINT_CREATOR
                        else:
                            one.UserId.Point += Constants.SUCCESS_GET_POINT_COMMON
                    one.UserId.save()
                    one.save()
        except:
            Success = False
    return Success
def AddUserActivity(TheUserID, TheActivityID, TheStatus, TheRole, TheJoinReason):
	'''
	描述:将一条报名信息加入数据库	
	参数:用户id,活动id,状态,权限,报名原因(没有就是None)
	返回:成功{result:success},失败{result:fail,reason:xxx, code:xxx}
	'''
	Success = True
	Return = {}
	Code = Constants.UNDEFINED_NUMBER
	Reason = ""
	TheSubmitTime = -1
	TheJoinTime = -1
	TheCheckTime = -1
	if Success:
		try:
			TheUser = User.objects.get(OpenID = TheUserID)
			TheActivity = Activity.objects.get(ID = TheActivityID)
		except:
			Success = False
			Reason = "未找到用户或活动"
			Code = Constants.ERROR_CODE_NOT_FOUND
	if Success:
		try:
			TheSubmitTime = GlobalFunctions.GetCurrentTime()
			TheCheckTime = Constants.UNDEFINED_NUMBER
			if TheStatus != Constants.USER_STATUS_WAITVALIDATE:
				TheJoinTime = TheSubmitTime
				TheActivity.CurrentUser = TheActivity.CurrentUser + 1
			else:
				TheCheckTime = Constants.UNDEFINED_NUMBER
			TheActivity.save()
			#print(TheJoinTime, TheCheckTime)
			if TheJoinReason == None:
				TheJoinReason = "无"
			try:
				TheJoinInformation = JoinInformation.objects.get(UserId = TheUser, ActivityId = TheActivity)
				TheJoinInformation.delete()
			except:
				donothing = 0
			TheJoinInformation = JoinInformation.objects.create(UserId = TheUser, ActivityId = TheActivity, Status = TheStatus,\
			Role = TheRole, SubmitTime = TheSubmitTime, JoinTime = TheJoinTime, CheckTime = TheCheckTime, JoinReason = TheJoinReason)
			TheJoinInformation.save()
		except:
			Success = False
			Reason = "添加记录失败"
			Code = Constants.ERROR_CODE_UNKNOWN
	if Success:
		Return["result"] = "success"
	else:
		Return["result"] = "fail"
		Return["reason"] = Reason
		Return["code"] = Code
	return Return
def QueryUser(ID):
    '''
	描述:给定用户id,查询用户具体信息
	参数:用户id
	返回:一个字典,里面有用户id,名字,性别,状态,教育信息(数组)
	如果没有就返回空字典
	{
  		"name": "李肇阳",
  		"campusIdentity": [
    {
      "enrollmentYear": "2014",
      "department": "软件学院",
      "enrollmentType": "Undergraduate"
    },
    {
      "enrollmentYear": "2018",
      "department": "软件学院",
      "enrollmentType": "Master"
    }
  	]
	}
	'''
    Success = True
    Object = None
    #查询
    if Success:
        try:
            Object = User.objects.get(OpenID=ID)
        except:
            Success = False
    #print(Info)

    Result = {}
    if Success:
        try:
            Result["name"] = Object.Name
            Result["avatarUrl"] = GlobalFunctions.GetTrueAvatarUrlUser(
                Object.AvatarURL)
            Result["status"] = Object.Status
            Result["point"] = Object.Point
        except:
            Success = False

    #处理教育信息数据
    if Success:
        try:
            Result["campusIdentity"] = QueryEducation(Object.Education.all())
        except:
            Success = False
    if Success == False:
        Result = {}
    return Result
def ReportActivity(TheUserID, TheActivityID, TheReportReason):
	'''
	描述:举报函数	
	参数:用户id,活动id, 举报原因
	返回:成功{result: success},失败{result:fail,reason:xxx, code:xxx}
	'''
	Success = True
	Reason = ""
	Return = {}
	Code = Constants.UNDEFINED_NUMBER
	TheStatus = -1
	TheRole = -1
	if Success:
		try:
			TheUser = User.objects.get(OpenID = TheUserID)
			TheActivity = Activity.objects.get(ID = TheActivityID)
		except:
			Success = False
			Reason = "未找到用户或活动"
			Code = Constants.ERROR_CODE_NOT_FOUND
	#print(Success)	
	TheRole = Constants.USER_ROLE_COMMONER
	if Success:
		if JudgeValid.JudgeActivityNormal(TheActivityID) != True: 
			Success = False
			Reason = "活动状态为异常或结束,不能操作!"
			Code = Constants.ERROR_CODE_INVALID_CHANGE

	if Success:
		try:
			TheSubmitTime = GlobalFunctions.GetCurrentTime()
			try:
				TheReportInformation = ReportInformation.objects.get(UserId = TheUser, ActivityId = TheActivity)
				TheReportInformation.delete()
			except:
				donothing = 0
			TheReportInformation = ReportInformation.objects.create(UserId = TheUser, ActivityId = TheActivity, \
			SubmitTime = TheSubmitTime, Reason = TheReportReason)
			TheReportInformation.save()
		except:
			Success = False
			Reason = "添加举报记录失败"
			Code = Constants.ERROR_CODE_UNKNOWN
	#print(Return)
	if Success:
		Return["result"] = "success"
	else:
		Return["result"] = "fail"
		Return["reason"] = Reason
		Return["code"] = Code
	return Return
Пример #11
0
def CheckActivitySendMessage():
    '''
	描述:根据时间判断是否要推送活动即将开始的消息,并且控制消息的发送
	参数: 无
	返回:无
	'''
    Success = True
    if Success:
        if (int(time.time()) - lastAccessTokenSetTime > 5400):
            GlobalFunctions.SetAccessToken()
    if Success:
        try:
            Info = Activity.objects.all()
        except:
            Success = False
    if Success:
        try:
            for item in Info:
                if item.StatusGlobal != Constants.ACTIVITY_STATUS_GLOBAL_NORMAL:
                    continue
                TheStartTime = item.StartTime
                if GlobalFunctions.JudgeWhetherSameMinute(
                        TheStartTime -
                        Constants.TIME_BEFORE_MESSAGE_ACTIVITY_WILL_START_HOUR
                ):
                    SendTimedMessageActivity(
                        item.ID,
                        Constants.MESSAGE_TYPE_ACTIVITY_WILL_START_HOUR)
                elif GlobalFunctions.JudgeWhetherSameMinute(
                        TheStartTime - Constants.
                        TIME_BEFORE_MESSAGE_ACTIVITY_WILL_START_MINUTE):
                    SendTimedMessageActivity(
                        item.ID,
                        Constants.MESSAGE_TYPE_ACTIVITY_WILL_START_MINUTE)
        except:
            Success = False
    return Success
Пример #12
0
def Login(TheUsername, ThePassword):
	'''
	描述:管理员登录的数据库函数
	参数:用户名,密码
	返回:成功{result:success}
		 失败:{result:fail,reason:xxx,code:xxx}
		 成功还有session
	'''
	Success = True
	Reason = ""
	TheSession = ""
	Code = 0
	Return = {}
	print(TheUsername, ThePassword)
	if Success:
		try:
			TheAdmin = Admin.objects.get(Username = TheUsername)
		except:
			Success = False
			Reason = "帐号不存在!"
			Code = Constants.ERROR_CODE_NOT_FOUND
	print(Success)
	if Success:
		try:
			if check_password(ThePassword, TheAdmin.Password) != True:
				Success = False
				Reason = "密码不正确!"  
				Code = Constants.ERROR_CODE_NOT_FOUND
		except:
			Success = False
			Reason = "帐号不存在!"
			Code = Constants.ERROR_CODE_NOT_FOUND
	if Success:
		try:
			TheSession = GlobalFunctions.GenerateSessionID()
			TheAdmin.Session = TheSession
			TheAdmin.save()
		except:
			Success = False
			Reason = "登录失败!"
			Code = Constants.ERROR_CODE_UNKNOWN
	if Success:
		Return["result"] = "success"
		Return["session"] = TheSession
	else:
		Return["result"] = "fail"
		Return["reason"] = Reason
		Return["code"] = Code
	return Return
def ShowAllMembers(TheActivityID):
	'''
	描述:查询活动所有成员---一般用户
	参数: 活动id
	返回:第一个是一个字典,里面就一个字典数组participantList,每个字典有人员的Openid,权限,状态,失败为空
		 第二个是原因和错误码,如果成功就是空,否则有reason和code
	'''
	Result = {}
	ErrorInfo = {}
	Success = True
	ResultList = []
	Reason = ""
	Code = 0
	if Success:
		try:
			TheActivity = Activity.objects.get(ID = TheActivityID)
			TheJoinActivityList = JoinInformation.objects.filter(ActivityId = TheActivity)
		except:
			Success = False
			Reason = "未找到活动!"
			Code = Constants.ERROR_CODE_NOT_FOUND
	if Success:
		try:
			for item in TheJoinActivityList:
				TheResult = {}
				TheResult["openId"] = item.UserId.OpenID
				TheResult["selfStatus"] = item.Status
				TheResult["selfRole"] = item.Role
				TheResult["name"] = item.UserId.Name
				TheResult["avatarUrl"] = GlobalFunctions.GetTrueAvatarUrlUser(item.UserId.AvatarURL)
				if JudgeValid.JudgeUserStatusJoined(item.Status):
					ResultList.append(TheResult)
		except:
			Success = False
			Reason = "查询活动成员失败!"
			Code = Constants.ERROR_CODE_UNKNOWN
	if Success:
		Result["participantList"] = ResultList
		ErrorInfo = {}
	else:
		Result = {}
		ErrorInfo["reason"] = Reason
		ErrorInfo["code"] = Code
	return Result, ErrorInfo
Пример #14
0
def QueryActivity(TheActivityID):
    '''
	描述:给定活动id,查询活动基本信息
	参数:活动id
	返回:一个字典,里面有活动各种信息
	如果没有就返回空字典
	'''
    Success = True
    Result = {}
    if Success:
        try:
            Info = Activity.objects.get(ID=TheActivityID)
            Result["name"] = Info.Name
            Result["place"] = Info.Place
            Result["createTime"] = GlobalFunctions.TimeStampToTimeString(
                int(Info.CreateTime))
            Result["start"] = GlobalFunctions.TimeStampToTimeString(
                int(Info.StartTime))
            Result["end"] = GlobalFunctions.TimeStampToTimeString(
                int(Info.EndTime))
            Result["signupBeginAt"] = GlobalFunctions.TimeStampToTimeString(
                int(Info.SignUpStartTime))
            Result["signupStopAt"] = GlobalFunctions.TimeStampToTimeString(
                int(Info.SignUpEndTime))
            Result["minUser"] = int(Info.MinUser)
            Result["maxUser"] = int(Info.MaxUser)
            Result["curUser"] = int(Info.CurrentUser)
            Result["type"] = Info.Type
            Result["statusGlobal"] = int(Info.StatusGlobal)
            Result["statusJoin"] = int(Info.StatusJoin)
            Result["statusCheck"] = int(Info.StatusCheck)
            Result["tags"] = GlobalFunctions.SplitTags(Info.Tags)
            Result["imageUrl"] = GlobalFunctions.GetTrueAvatarUrlActivity(
                Info.ImageURL)
        except:
            Success = False
    if Success == False:
        Result = {}
    return Result
 def GetOneActivityInfo(self, TheID):
     TheResult = {}
     Success = True
     try:
         TheActivity = Activity.objects.get(ID=TheID)
         TheResult["id"] = TheID
         TheResult["name"] = TheActivity.Name
         TheResult["place"] = TheActivity.Place
         TheResult["createTime"] = GlobalFunctions.TimeStampToTimeString(
             int(TheActivity.CreateTime))
         TheResult["start"] = GlobalFunctions.TimeStampToTimeString(
             int(TheActivity.StartTime))
         TheResult["end"] = GlobalFunctions.TimeStampToTimeString(
             int(TheActivity.EndTime))
         TheResult["signupBeginAt"] = GlobalFunctions.TimeStampToTimeString(
             int(TheActivity.SignUpStartTime))
         TheResult["signupStopAt"] = GlobalFunctions.TimeStampToTimeString(
             int(TheActivity.SignUpEndTime))
         TheResult["minUser"] = int(TheActivity.MinUser)
         TheResult["maxUser"] = int(TheActivity.MaxUser)
         TheResult["curUser"] = int(TheActivity.CurrentUser)
         TheResult["type"] = TheActivity.Type
         TheResult["statusGlobal"] = int(TheActivity.StatusGlobal)
         TheResult["statusJoin"] = int(TheActivity.StatusJoin)
         TheResult["statusCheck"] = int(TheActivity.StatusCheck)
         TheResult["imageUrl"] = GlobalFunctions.GetTrueAvatarUrlActivity(
             TheActivity.ImageURL)
         TheResult["tags"] = GlobalFunctions.SplitTags(TheActivity.Tags)
         #print(TheResult)
         if JudgeValid.JudgeActivityCanBeSearched(TheID) != True:
             Success = False
     except:
         Success = False
     if Success:
         return TheResult
     else:
         return {}
Пример #16
0
def AdvancedSearch(TheUserID, Information, TheLastSeenID, TheMost):
    '''
	描述:高级检索
	参数:用户openid,检索信息,上一个id,最多
	返回:Result, errorinfo
	'''
    Success = True
    Return = {}
    ErrorInfo = {}
    Reason = ""
    Code = Constants.UNDEFINED_NUMBER
    SearchDictionary = {}
    if Success:
        try:
            TheUser = User.objects.get(OpenID=TheUserID)
        except:
            Success = False
            Reason = "用户不存在!"
            Code = Constants.ERROR_CODE_INVALID_PARAMETER
    #读取修改数据
    if Success:
        try:
            if "place" in Information:
                SearchDictionary["place"] = Information["place"]
            else:
                SearchDictionary["place"] = ""
            if "startMin" in Information:
                SearchDictionary["startMin"] = int(
                    GlobalFunctions.TimeStringToTimeStamp(
                        Information["startMin"]))
            else:
                SearchDictionary["startMin"] = 0
            if "startMax" in Information:
                SearchDictionary["startMax"] = int(
                    GlobalFunctions.TimeStringToTimeStamp(
                        Information["startMax"]))
            else:
                SearchDictionary["startMax"] = Constants.MAX_NUMBER
            if "endMin" in Information:
                SearchDictionary["endMin"] = int(
                    GlobalFunctions.TimeStringToTimeStamp(
                        Information["endMin"]))
            else:
                SearchDictionary["endMin"] = 0
            if "endMax" in Information:
                SearchDictionary["endMax"] = int(
                    GlobalFunctions.TimeStringToTimeStamp(
                        Information["endMax"]))
            else:
                SearchDictionary["endMax"] = Constants.MAX_NUMBER
            if "signupBeginAtMin" in Information:
                SearchDictionary["signupBeginAtMin"] = int(
                    GlobalFunctions.TimeStringToTimeStamp(
                        Information["signupBeginAtMin"]))
            else:
                SearchDictionary["signupBeginAtMin"] = 0
            if "signupBeginAtMax" in Information:
                SearchDictionary["signupBeginAtMax"] = int(
                    GlobalFunctions.TimeStringToTimeStamp(
                        Information["signupBeginAtMax"]))
            else:
                SearchDictionary["signupBeginAtMax"] = Constants.MAX_NUMBER
            if "signupStopAtMin" in Information:
                SearchDictionary["signupStopAtMin"] = int(
                    GlobalFunctions.TimeStringToTimeStamp(
                        Information["signupStopAtMin"]))
            else:
                SearchDictionary["signupStopAtMin"] = 0
            if "signupStopAtMax" in Information:
                SearchDictionary["signupStopAtMax"] = int(
                    GlobalFunctions.TimeStringToTimeStamp(
                        Information["signupStopAtMax"]))
            else:
                SearchDictionary["signupStopAtMax"] = Constants.MAX_NUMBER
            if "type" in Information:
                SearchDictionary["type"] = Information["type"]
            else:
                SearchDictionary["type"] = ""
            if "statusGlobal" in Information:
                SearchDictionary["statusGlobal"] = Information["statusGlobal"]
            else:
                SearchDictionary["statusGlobal"] = Constants.UNDEFINED_NUMBER
            if "statusJoin" in Information:
                SearchDictionary["statusJoin"] = Information["statusJoin"]
            else:
                SearchDictionary["statusJoin"] = Constants.UNDEFINED_NUMBER
            if "statusCheck" in Information:
                SearchDictionary["statusCheck"] = Information["statusCheck"]
            else:
                SearchDictionary["statusCheck"] = Constants.UNDEFINED_NUMBER
            if "selfStatus" in Information:
                SearchDictionary["selfStatus"] = Information["selfStatus"]
            else:
                SearchDictionary["selfStatus"] = Constants.UNDEFINED_NUMBER - 1
            if "ruleForMe" in Information:
                SearchDictionary["ruleForMe"] = Information["ruleForMe"]
            else:
                SearchDictionary["ruleForMe"] = Constants.UNDEFINED_NUMBER - 1
        except:
            Success = False
            Reason = "高级检索格式不合法"
            Code = Constants.ERROR_CODE_INVALID_PARAMETER
    if Success:
        try:
            JudgeResult = {}
            JudgeResult = JudgeValid.JudgeSearchStatusValid(SearchDictionary["statusGlobal"], SearchDictionary["statusJoin"], \
            SearchDictionary["statusCheck"], SearchDictionary["selfStatus"], SearchDictionary["ruleForMe"])
            if JudgeResult["result"] != "success":
                Success = False
                Reason = JudgeResult["reason"]
                Code = JudgeResult["code"]
            JudgeResult = JudgeValid.JudgeSearchTimeValid(
                SearchDictionary["startMin"], SearchDictionary["startMax"])
            if JudgeResult["result"] != "success":
                Success = False
                Reason = "最小开始时间必须小于等于最大开始时间!"
                Code = Constants.ERROR_CODE_INVALID_PARAMETER
            JudgeResult = JudgeValid.JudgeSearchTimeValid(
                SearchDictionary["endMin"], SearchDictionary["endMax"])
            if JudgeResult["result"] != "success":
                Success = False
                Reason = "最小结束时间必须小于等于最大结束时间!"
                Code = Constants.ERROR_CODE_INVALID_PARAMETER
            JudgeResult = JudgeValid.JudgeSearchTimeValid(
                SearchDictionary["signupBeginAtMin"],
                SearchDictionary["signupBeginAtMax"])
            if JudgeResult["result"] != "success":
                Success = False
                Reason = "最小开始报名时间必须小于等于最大开始报名时间!"
                Code = Constants.ERROR_CODE_INVALID_PARAMETER
            JudgeResult = JudgeValid.JudgeSearchTimeValid(
                SearchDictionary["signupStopAtMin"],
                SearchDictionary["signupStopAtMax"])
            if JudgeResult["result"] != "success":
                Success = False
                Reason = "最小结束报名时间必须小于等于最大结束报名时间!"
                Code = Constants.ERROR_CODE_INVALID_PARAMETER
        except:
            Success = False
            Reason = "高级检索格式不合法"
            Code = Constants.ERROR_CODE_INVALID_PARAMETER
    SearchResult = []
    #查询时间,地点,状态,直接数据库函数
    if Success:
        try:
            QuerySet = Activity.objects.all()
            Conditions = {'StartTime__gte': SearchDictionary["startMin"], 'StartTime__lte': SearchDictionary["startMax"],\
            'EndTime__gte': SearchDictionary["endMin"], 'EndTime__lte': SearchDictionary["endMax"],\
            'SignUpStartTime__gte': SearchDictionary["signupBeginAtMin"], 'SignUpStartTime__lte': SearchDictionary["signupBeginAtMax"],\
            'SignUpEndTime__gte': SearchDictionary["signupStopAtMin"], 'SignUpEndTime__lte': SearchDictionary["signupStopAtMax"]}
            if SearchDictionary["statusGlobal"] != Constants.UNDEFINED_NUMBER:
                Conditions['StatusGlobal'] = SearchDictionary["statusGlobal"]
            if SearchDictionary["statusJoin"] != Constants.UNDEFINED_NUMBER:
                Conditions['StatusJoin'] = SearchDictionary["statusJoin"]
            if SearchDictionary["statusCheck"] != Constants.UNDEFINED_NUMBER:
                Conditions['StatusCheck'] = SearchDictionary["statusCheck"]
            if SearchDictionary["place"] != '':
                Conditions["Place__icontains"] = SearchDictionary["place"]
            SearchResult = QuerySet.filter(**Conditions)
        except:
            Success = False
            Reason = "高级检索失败"
            Code = Constants.ERROR_CODE_UNKNOWN

    #查询活动类型,加入后结果等
    NewSearchResult = []
    if Success:
        try:
            i = len(SearchResult) - 1
            while i >= 0:
                item = SearchResult[i]
                WhetherMatch = True
                if SearchDictionary["type"] != "":
                    if JudgeValid.JudgeActivityTypeMatch(
                            SearchDictionary["type"], item.Type) != True:
                        WhetherMatch = False
                if SearchDictionary[
                        "selfStatus"] != Constants.UNDEFINED_NUMBER - 1:
                    TheStatus = JudgeValid.GetSelfStatus(TheUserID, item.ID)
                    if TheStatus != SearchDictionary["selfStatus"]:
                        WhetherMatch = False
                if SearchDictionary[
                        "ruleForMe"] != Constants.UNDEFINED_NUMBER - 1:
                    TheRule = JudgeValid.GetSelfJoinStatus(TheUserID, item.ID)
                    if TheRule != SearchDictionary["ruleForMe"]:
                        WhetherMatch = False
                if JudgeValid.JudgeActivityCanBeSearched(item.ID) != True:
                    WhetherMatch = False
                if WhetherMatch == True:
                    print(item.ID)
                    TheInfo = QueryActivity(item.ID)
                    TheInfo["id"] = item.ID
                    NewSearchResult.append(TheInfo)
                i -= 1
        except:
            Success = False
            Reason = "高级检索失败"
            Code = Constants.ERROR_CODE_UNKNOWN

    ReturnList = []
    #分页显示
    if Success:
        CurrentNum = 0
        WhetherFindStart = False
        if TheLastSeenID == Constants.UNDEFINED_NUMBER:
            WhetherFindStart = True
        for item in NewSearchResult:
            if WhetherFindStart == True:
                if TheMost != Constants.UNDEFINED_NUMBER and CurrentNum >= TheMost:
                    break
                ReturnList.append(item)
                CurrentNum += 1
            if TheLastSeenID != Constants.UNDEFINED_NUMBER and item[
                    "id"] == TheLastSeenID:
                WhetherFindStart = True

    #print(NewSearchResult)
    if Success == False:
        ErrorInfo["reason"] = Reason
        ErrorInfo["code"] = Code
    else:
        Return["activityList"] = ReturnList
        ErrorInfo = {}
    return Return, ErrorInfo
Пример #17
0
def UploadPicture(request):
    '''
    描述:处理上传图片
    参数:request
    成功返回url
    失败则是
    {
    "errid":xxx,
    "errmsg":"xxxx"
    }
    '''
    Success = True
    Return = {}
    Info = {}
    Reason = ""
    ErrorID = Constants.UNDEFINED_NUMBER
    TheSession = ""
    TheUserID = ""
    TheData = None
    TheURL = ""
    #获取请求数据
    if Success:
        try:
            TheSession = request.GET.get("session")
            TheData = request.FILES.get("file")
        except:
            Success = False
            Reason = "请求参数不合法!"
            ErrorID = Constants.ERROR_CODE_INVALID_PARAMETER

    #判断是否登录,获取待查询的openid
    if Success:
        try:
            TheUserID = UserManager.GetCurrentUser(TheSession)
            if TheUserID == None:
                Success = False
                Reason = "用户未登录!"
                ErrorID = Constants.ERROR_CODE_LOGIN_ERROR
        except:
            Success = False
            Reason = "用户未登录!"
            ErrorID = Constants.ERROR_CODE_LOGIN_ERROR

    #调用数据库函数
    if Success:
        try:
            Info = GlobalFunctions.UploadPicture(TheData)
            #print(Info)
            if Info["result"] == "success":
                TheURL = Info["url"]
            else:
                Success = False
                Reason = Info["reason"]
                ErrorID = Info["code"]
        except:
            Success = False
            Reason = "上传图片失败!"
            ErrorID = Constants.ERROR_CODE_NOT_FOUND

    if Success:
        Return["result"] = "success"
        Return["url"] = TheURL
    else:
        Return["errid"] = ErrorID
        Return["errmsg"] = Reason
    Response = JsonResponse(Return)
    if Success == True:
        Response.status_code = 200
    else:
        Response.status_code = 400
    return Response
Пример #18
0
from Alumni.LogicManager import JudgeValid
from Alumni.DatabaseManager import UserManager
from Alumni.DatabaseManager import ActivityManager
from Alumni.DatabaseManager import UserActivityManager
from Alumni.DatabaseManager import SearchAndRecommend
from Alumni.DatabaseManager import AdminManager
from Alumni.DatabaseManager import TimeManager
from Alumni.RequestHandler import UserHandler
from Alumni.RequestHandler import ActivityHandler
from Alumni.RequestHandler import UserActivityHandler
from Alumni.RequestHandler import SearchHandler
from Alumni.RequestHandler import OtherHandler
from Alumni.RequestHandler import AdminHandler

TheSearcher = SearchAndRecommend.WhooshSearcher.Create()
print(GlobalFunctions.SetAccessToken())
print(GlobalFunctions.GetAccessToken())
AdminManager.AddAdmin("kebab", "reich")

urlpatterns = [
    #处理用户请求url
    url(r'^login$', UserHandler.LoginUser),
    url(r'^alumniCheck$', UserHandler.GetAlumniInfo),
    url(r'^qhrcallback$', UserHandler.ReceiveAlunmiInfo),
    url(r'^userData$', UserHandler.QueryUser),
    url(r'^setAvatarUrl$', UserHandler.SetAvatarURL),
    url(r'^setExtraData$', UserHandler.SetExtraData),

    #处理活动请求url
    url(r'^createActivity$', ActivityHandler.StartActivity),
    url(r'^modifyActivity$', ActivityHandler.ChangeActivity),
Пример #19
0
def AddActivity(ID, Information):
    '''
	描述:添加一个活动到数据库	
	参数:创建者ID,数据信息
	返回:{result:success,activityId:xxx}/失败{result:fail,reason:xxx, code:xxx}
	'''
    Return = {}
    Success = True
    Code = Constants.UNDEFINED_NUMBER
    Reason = ""
    CurTime = 0
    StartTime = 0
    EndTime = 0
    StartSignTime = 0
    StopSignTime = 0
    TheMinUser = 0
    TheMaxUser = 0
    TheStatus = 0
    TheSearched = False
    TheGlobalRule = -1
    TheAcceptRule = []
    TheAuditRule = []
    TheRejectRule = []
    TheType = ""
    #把时间转化为时间戳,并且判断时间和人数是否合法
    if Success:
        try:
            CurTime = GlobalFunctions.GetCurrentTime()
            StartTime = GlobalFunctions.TimeStringToTimeStamp(
                Information["start"])
            EndTime = GlobalFunctions.TimeStringToTimeStamp(Information["end"])
            if 'signupBeginAt' in Information:
                StartSignTime = GlobalFunctions.TimeStringToTimeStamp(
                    Information["signupBeginAt"])
            else:
                StartSignTime = CurTime
            if 'signupStopAt' in Information:
                StopSignTime = GlobalFunctions.TimeStringToTimeStamp(
                    Information["signupStopAt"])
            else:
                StopSignTime = StartTime
            if 'minUser' in Information:
                TheMinUser = int(Information["minUser"])
            else:
                TheMinUser = 0
            if 'maxUser' in Information:
                TheMaxUser = int(Information["maxUser"])
            else:
                TheMaxUser = Constants.UNDEFINED_NUMBER
            JudgeResult = JudgeValid.JudgeParameterValid(
                CurTime, StartTime, EndTime, StartSignTime, StopSignTime, 1,
                TheMinUser, TheMaxUser)
            if "imageUrl" in Information:
                TheImageURL = Information["imageUrl"]
            else:
                TheImageURL = "UNDEFINED"
            if "position" in Information:
                ThePosition = Information["position"]
            else:
                ThePosition = ""
            if JudgeResult["result"] != "success":
                Success = False
                Reason = JudgeResult["reason"]
                Code = Constants.ERROR_CODE_INVALID_CHANGE
        except:
            Success = False
            Reason = "输入的开始/结束/开始报名/报名截止时间不合理!"
            Code = Constants.ERROR_CODE_INVALID_PARAMETER

    #判断活动状态,类型等是否合法
    if Success:
        try:
            TheType = Information["type"]
            TheSearched = bool(Information["canBeSearched"])
            if JudgeValid.JudgeActivityTypeValid(TheType) == False:
                Success = False
                Reason = "活动类型不合法,添加活动失败!"
                Code = Constants.ERROR_CODE_INVALID_PARAMETER
            TheStatusGlobal = GlobalFunctions.GetStartActivityGlobalStatus(
                TheType)
            TheStatusJoin = GlobalFunctions.GetStartActivityJoinStatus(
                StartSignTime, StopSignTime)
            TheStatusCheck = GlobalFunctions.GetStartActivityCheckStatus(
                StartTime, EndTime)
        except:
            Success = False
            Reason = "参数不合法,添加活动失败!"
            Code = Constants.ERROR_CODE_INVALID_PARAMETER

    #获得标签,正文,头像
    if Success:
        try:
            TheTagsList = Information["tags"]
            TheDescription = Information["description"]
            if JudgeValid.JudgeTagListValid(TheTagsList) != True:
                Success = False
                Reason = "参数不合法,标签不能带有英文逗号!"
                Code = Constants.ERROR_CODE_INVALID_PARAMETER
            TheTags = GlobalFunctions.MergeTags(TheTagsList)
        except:
            Success = False
            Reason = "参数不合法,添加活动失败!"
            Code = Constants.ERROR_CODE_INVALID_PARAMETER

    #获得高级报名信息
    if Success:
        try:
            #判断是否合法
            TheGlobalRule = Information["rules"]["ruleType"]
            if JudgeValid.JudgeRuleTypeValid(TheGlobalRule) != True:
                Success = False
                Reason = "参数不合法,规则类型不合法!"
                Code = Constants.ERROR_CODE_INVALID_PARAMETER
            TheJudgeAdvanceRuleResult = JudgeValid.JudgeAdvancedRuleValid(
                Information["rules"])
            #print(TheJudgeAdvanceRuleResult)
            if TheJudgeAdvanceRuleResult["result"] != "success":
                Success = False
                Reason = TheJudgeAdvanceRuleResult["reason"]
                Code = TheJudgeAdvanceRuleResult["code"]
            try:
                TheAcceptRule = Information["rules"]["accept"]
            except:
                TheAcceptRule = []
            try:
                TheAuditRule = Information["rules"]["needAudit"]
            except:
                TheAuditRule = []
            try:
                TheRejectRule = Information["rules"]["reject"]
            except:
                TheRejectRule = []
        except:
            Success = False
            Reason = "参数不合法,添加活动失败!"
            Code = Constants.ERROR_CODE_INVALID_PARAMETER

    #print(CurTime, StartTime, EndTime, StartSignTime, StopSignTime)
    #print(Success)
    #插入数据库
    if Success:
        try:
            TheName = Information["name"]
            ThePlace = Information["place"]

            #TheCreator = User.objects.get(OpenID = ID)
            #print(TheCreator.ID)
            TheCreateTime = GlobalFunctions.GetCurrentTime()
            NewActivity = Activity.objects.create(Name = TheName, Place = ThePlace, CreateTime = TheCreateTime, StartTime = StartTime, EndTime = EndTime, SignUpStartTime = StartSignTime,\
            SignUpEndTime = StopSignTime, MinUser = TheMinUser, MaxUser = TheMaxUser, CurrentUser = 0, Type = TheType, \
            StatusGlobal = TheStatusGlobal, StatusJoin = TheStatusJoin, StatusCheck = TheStatusCheck, CanBeSearched = TheSearched, \
            GlobalRule = TheGlobalRule, Tags = TheTags, Description = TheDescription, ImageURL = TheImageURL, GPSPlace = ThePosition)
            NewActivity.save()
            ActivityID = NewActivity.ID

            TheSearcher = SearchAndRecommend.WhooshSearcher.Create()
            TheSearcher.AddOneInfo(ActivityID, TheName + ',' + TheTags)
        except:
            Success = False
            Reason = "参数不合法,添加活动失败!"
            Code = Constants.ERROR_CODE_INVALID_PARAMETER
    if Success:
        if "rules" in Information:
            try:
                #添加rules
                for item in TheAcceptRule:
                    AddAdvancedRules(ActivityID, item,
                                     Constants.ADVANCED_RULE_ACCEPT)
                for item in TheAuditRule:
                    AddAdvancedRules(ActivityID, item,
                                     Constants.ADVANCED_RULE_AUDIT)
                for item in TheRejectRule:
                    AddAdvancedRules(ActivityID, item,
                                     Constants.ADVANCED_RULE_REJECT)
            except:
                Success = False
                Reason = "参数不合法,添加活动失败!"
                Code = Constants.ERROR_CODE_INVALID_PARAMETER
    #print(Success)
    #让creator加入活动
    if Success:
        try:
            #print(int(Return["id"]))
            JoinActivityResult = AddCreatorIntoActivity(ID, ActivityID)
            if JoinActivityResult["result"] != "success":
                Success = False
                Reason = JoinActivityResult["reason"]
                Code = JoinActivityResult["code"]
            else:
                Return["activityId"] = ActivityID
        except:
            Success = False
            Reason = "添加活动失败"
            Code = Constants.ERROR_CODE_UNKNOWN
    if Success:
        if TheStatusGlobal == Constants.ACTIVITY_STATUS_GLOBAL_NORMAL:
            Return["result"] = "success"
        else:
            Return["result"] = "needAudit"
    else:
        Return["result"] = "fail"
        Return["reason"] = Reason
        Return["code"] = Code
    return Return
Пример #20
0
def GetAlumniInfo(request):
    '''
    描述:获取校友信息
    参数:request
    成功返回:
    {
    "params": {
    "appId": "wx1ebe3b2266f4afe0",
    "path": "pages/index/index",
    "envVersion": "develop",
    "extraData": {
      "origin": "miniapp",
      "ticket": "52ec7c69-9d7c-4495-b07f-7e10ab4ad24f",
      "type": "oauth"
    }
    }
    }
    失败返回:
    {"errid": 101, "errmsg": "身份信息不存在"}
    '''
    Success = True
    Return = {}
    Info = {}
    TheParam = {}
    TheJson = {}
    ErrorId = Constants.UNDEFINED_NUMBER
    Reason = ""
    TheSession = ""
    TheOpenID = ""
    TheSessionKey = ""
    if Success:
        try:
            TheSession = request.GET.get("session")
        except:
            Success = False
            ErrorId = Constants.ERROR_CODE_INVALID_PARAMETER
            Reason = "请求参数不合法!"
    if Success:
        try:
            TheParam = GlobalFunctions.GetAppIDThis()
        except:
            Success = False
            ErrorId = Constants.ERROR_CODE_INVALID_PARAMETER
            Reason = "请求参数不合法!"
    #换取openid 和 key
    #print(TheParam)
    if Success:
        try:
            TheRequest = requests.post(
                "https://alumni-test.iterator-traits.com/fake-info-tsinghua-org/mp/oauth/initiate/miniapp",
                data=json.dumps(TheParam),
                timeout=(5, 10),
                allow_redirects=True)
        except:
            Success = False
            ErrorId = Constants.ERROR_CODE_NETWORK_ERROR
            Reason = "网络繁忙,访问超时!"
    #print(TheRequest)
    if Success:
        try:
            if TheRequest.status_code < 200 or TheRequest.status_code >= 400:
                Success = False
                ErrorId = Constants.ERROR_CODE_NETWORK_ERROR
                Reason = "网络繁忙,访问清华人失败!!"
            TheJson = TheRequest.json()
            TheRequestID = TheJson["requestId"]
            Info = TheJson["params"]
        except:
            Success = False
            ErrorId = Constants.ERROR_CODE_NETWORK_ERROR
            Reason = "网络繁忙,访问清华人失败!"

    if Success:
        if UserManager.AddRequestID(TheSession, TheRequestID) != True:
            Success = False
            ErrorId = Constants.ERROR_CODE_LOGIN_ERROR
            Reason = "用户未登录!"

    if Success == False:
        Return["errid"] = ErrorId
        Return["errmsg"] = Reason
    else:
        Return["params"] = Info
    Response = JsonResponse(Return)
    if Success == True:
        Response.status_code = 200
    else:
        Response.status_code = 400
    return Response
Пример #21
0
def LoginUser(request):
    '''
    描述:处理登录请求
    参数:request
    成功返回:
    { 
    "result": "success",
    "session": "123456abcdef",
    "openId": "asfsfs"
    }
    失败返回:
    {"errid": 101, "errmsg": "身份信息不存在"}
    '''
    Success = True
    Return = {}
    Info = {}
    TheParam = {}
    ErrorId = Constants.UNDEFINED_NUMBER
    Reason = ""
    TheCode = ""
    TheSession = ""
    TheOpenID = ""
    TheSessionKey = ""
    if Success:
        try:
            TheCode = request.GET.get("code")
        except:
            Success = False
            ErrorId = Constants.ERROR_CODE_INVALID_PARAMETER
            Reason = "请求参数不合法!"
    if Success:
        try:
            TheParam = {}
            TheParam = GlobalFunctions.GetAppIDWechat()
            TheParam["js_code"] = TheCode
            TheParam["grant_type"] = "authorization_code"
        except:
            Success = False
            ErrorId = Constants.ERROR_CODE_INVALID_PARAMETER
            Reason = "请求参数不合法!"
    #换取openid 和 key
    #print(TheParam)
    if Success:
        try:
            TheRequest = requests.get(
                "https://api.weixin.qq.com/sns/jscode2session",
                params=TheParam,
                timeout=(5, 10),
                allow_redirects=True)
        except:
            Success = False
            ErrorId = Constants.ERROR_CODE_NETWORK_ERROR
            Reason = "网络繁忙,访问超时!"

    if Success:
        try:
            if TheRequest.status_code < 200 or TheRequest.status_code >= 400:
                Success = False
                ErrorId = Constants.ERROR_CODE_NETWORK_ERROR
                Reason = "网络繁忙,访问微信失败!!"
            TheJson = TheRequest.json()
            #print(TheJson)
            if "errcode" in TheJson:
                if TheJson["errcode"] == -1:
                    Success = False
                    ErrorId = Constants.ERROR_CODE_NETWORK_ERROR
                    Reason = "网络繁忙,访问微信失败!"
                elif TheJson["errcode"] == 40029:
                    Success = False
                    ErrorId = Constants.ERROR_CODE_INVALID_PARAMETER
                    Reason = "Code无效!"
                elif TheJson["errcode"] == 45011:
                    Success = False
                    ErrorId = Constants.ERROR_CODE_INVALID_CHANGE
                    Reason = "访问过于频繁,每个用户每分钟最多访问100次!"
                elif TheJson["errcode"] != 0:
                    Success = False
                    ErrorId = Constants.ERROR_CODE_NETWORK_ERROR
                    Reason = TheJson["errmsg"]
        except:
            Success = False
            ErrorId = Constants.ERROR_CODE_NETWORK_ERROR
            Reason = "网络繁忙,访问微信失败!"

    if Success:
        try:
            TheOpenID = TheJson["openid"]
            TheSessionKey = TheJson["session_key"]
        except:
            Success = False
            ErrorId = Constants.ERROR_CODE_NETWORK_ERROR
            Reason = "网络繁忙,访问微信失败!"

    if Success:
        try:
            TheSession = GlobalFunctions.GenerateSessionID()
        except:
            Success = False
            ErrorId = Constants.ERROR_CODE_UNKNOWN
            Reason = "生成session失败!"

    if Success:
        try:
            Return = UserManager.AddUserID(TheOpenID, TheSessionKey,
                                           TheSession)
        except:
            Success = False
            ErrorId = Constants.ERROR_CODE_UNKNOWN
            Reason = "访问数据库失败!"
    if Success == False:
        Return["errid"] = ErrorId
        Return["errmsg"] = Reason

    Response = JsonResponse(Return)
    if Success == True:
        Response.status_code = 200
    else:
        Response.status_code = 400
    return Response
def ShowAllAuditMembers(TheUserID, TheActivityID):
	'''
	描述:查询活动所有待审核成员---管理员
	参数: 用户id,活动id
	返回:
	第一个是一个字典,失败为空,成功格式如下
	{
  	"members": [
    {
      "openId": "xxxxxxx",
      "name": "李大爷",
      "submitTime": "2019-11-01 08:00:00",
      "submitMsg": "我是管理员的爸爸,不让我参加?"
    }
  	]
	}
	第二个是错误信息,成功空字典,否则有reason和code
	'''
	Result = {}
	ErrorInfo = {}
	Reason = ""
	Code = 0
	Success = True
	ResultList = []
	if Success:
		try:
			if JudgeValid.JudgeWhetherManager(TheUserID, TheActivityID) != True:
				Success = False
				Reason = "权限不足,需要是管理员或创建者!"
				Code = Constants.ERROR_CODE_LACK_ACCESS
			TheActivity = Activity.objects.get(ID = TheActivityID)
			TheJoinActivityList = JoinInformation.objects.filter(ActivityId = TheActivity)
			if TheActivity.CanBeSearched != True:
				Success = False
				Reason = "未找到活动!"
				Code = Constants.ERROR_CODE_NOT_FOUND
		except:
			Success = False
			Reason = "未找到活动!"
			Code = Constants.ERROR_CODE_NOT_FOUND
	
	if Success:
		try:
			for item in TheJoinActivityList:
				TheResult = {}
				if item.Status == Constants.USER_STATUS_WAITVALIDATE:
					TheResult["openId"] = item.UserId.OpenID
					TheResult["name"] = item.UserId.Name
					TheResult["avatarUrl"] = GlobalFunctions.GetTrueAvatarUrlUser(item.UserId.AvatarURL)
					TheResult["submitTime"] = GlobalFunctions.TimeStampToTimeString(item.SubmitTime)
					TheResult["point"] = item.UserId.Point
					TheResult["submitMsg"] = item.JoinReason
					ResultList.append(TheResult)
		except:
			Success = False
			Reason = "查询待审核成员失败!"
			Code = Constants.ERROR_CODE_UNKNOWN
	if Success:
		Result["users"] = ResultList
		ErrorInfo = {}
	else:
		Result = {}
		ErrorInfo["reason"] = Reason
		ErrorInfo["code"] = Code
	return Result, ErrorInfo
Пример #23
0
def ChangeActivity(TheUserID, Information):
    '''
	描述:修改活动信息
	参数:用户openid,待修改信息
	返回:{result:success}/{result:fail,reason:xxx, code:xxx}
	'''
    Success = True
    Return = {}
    Reason = ""
    Code = Constants.UNDEFINED_NUMBER
    ChangeDictionary = {}
    #判断是否能找到这个活动
    if Success:
        try:
            TheUser = User.objects.get(OpenID=TheUserID)
            TheActivity = Activity.objects.get(ID=Information["id"])
            if JudgeValid.JudgeWhetherManager(TheUserID,
                                              Information["id"]) != True:
                Success = False
                Reason = "没有修改权限,需要是管理员或者创建者!"
                Code = Constants.ERROR_CODE_LACK_ACCESS
        except:
            Success = False
            Reason = "没有修改权限"
            Code = Constants.ERROR_CODE_LACK_ACCESS
    if Success:
        if JudgeValid.JudgeActivityNormal(Information["id"]) != True:
            Success = False
            Reason = "活动状态为异常或结束,不能操作!"
            Code = Constants.ERROR_CODE_INVALID_CHANGE
    #读取修改数据
    WhetherJudgeTime = False
    if Success:
        try:
            if "name" in Information:
                ChangeDictionary["name"] = Information["name"]
            else:
                ChangeDictionary["name"] = TheActivity.Name
            if "place" in Information:
                ChangeDictionary["place"] = Information["place"]
            else:
                ChangeDictionary["place"] = TheActivity.Place
            if "start" in Information:
                WhetherJudgeTime = True
                ChangeDictionary["start"] = int(
                    GlobalFunctions.TimeStringToTimeStamp(
                        Information["start"]))
            else:
                ChangeDictionary["start"] = TheActivity.StartTime
            if "end" in Information:
                WhetherJudgeTime = True
                ChangeDictionary["end"] = int(
                    GlobalFunctions.TimeStringToTimeStamp(Information["end"]))
            else:
                ChangeDictionary["end"] = TheActivity.EndTime
            if "signupBeginAt" in Information:
                WhetherJudgeTime = True
                ChangeDictionary["signupBeginAt"] = int(
                    GlobalFunctions.TimeStringToTimeStamp(
                        Information["signupBeginAt"]))
            else:
                ChangeDictionary["signupBeginAt"] = TheActivity.SignUpStartTime
            if "signupStopAt" in Information:
                WhetherJudgeTime = True
                ChangeDictionary["signupStopAt"] = int(
                    GlobalFunctions.TimeStringToTimeStamp(
                        Information["signupStopAt"]))
            else:
                ChangeDictionary["signupStopAt"] = TheActivity.SignUpEndTime
            if "minUser" in Information:
                ChangeDictionary["minUser"] = int(Information["minUser"])
            else:
                ChangeDictionary["minUser"] = TheActivity.MinUser
            if "maxUser" in Information:
                ChangeDictionary["maxUser"] = int(Information["maxUser"])
            else:
                ChangeDictionary["maxUser"] = TheActivity.MaxUser
            if "type" in Information:
                ChangeDictionary["type"] = Information["type"]
            else:
                ChangeDictionary["type"] = TheActivity.Type
            if "statusGlobal" in Information:
                ChangeDictionary["statusGlobal"] = Information["statusGlobal"]
            else:
                ChangeDictionary["statusGlobal"] = TheActivity.StatusGlobal
            if "statusJoin" in Information:
                ChangeDictionary["statusJoin"] = Information["statusJoin"]
            else:
                ChangeDictionary["statusJoin"] = TheActivity.StatusJoin
            if "statusCheck" in Information:
                ChangeDictionary["statusCheck"] = Information["statusCheck"]
            else:
                ChangeDictionary["statusCheck"] = TheActivity.StatusCheck
            if "canBeSearched" in Information:
                ChangeDictionary["canBeSearched"] = bool(
                    Information["canBeSearched"])
            else:
                ChangeDictionary["canBeSearched"] = TheActivity.CanBeSearched
            if "imageUrl" in Information:
                ChangeDictionary["imageUrl"] = Information["imageUrl"]
            else:
                ChangeDictionary["imageUrl"] = TheActivity.ImageURL
            if "position" in Information:
                ChangeDictionary["position"] = Information["position"]
            else:
                ChangeDictionary["position"] = TheActivity.GPSPlace

            if "tags" in Information:
                if JudgeValid.JudgeTagListValid(Information["tags"]) != True:
                    Success = False
                    Reason = "参数不合法,标签不能带有英文逗号!"
                    Code = Constants.ERROR_CODE_INVALID_PARAMETER
                ChangeDictionary["tags"] = GlobalFunctions.MergeTags(
                    Information["tags"])
            else:
                ChangeDictionary["tags"] = TheActivity.Tags
            #如果rules不存在就changedictionary为空,要判断
            if "rules" in Information:
                if "ruleType" in Information["rules"]:
                    ChangeDictionary["ruleType"] = Information["rules"][
                        "ruleType"]
                else:
                    ChangeDictionary["ruleType"] = TheActivity.GlobalRule
                ChangeDictionary["rules"] = Information["rules"]
            else:
                ChangeDictionary["rules"] = []
                ChangeDictionary["ruleType"] = TheActivity.GlobalRule
            ChangeDictionary["curTime"] = GlobalFunctions.GetCurrentTime()
            ChangeDictionary["curUser"] = TheActivity.CurrentUser

        except:
            Success = False
            Reason = "待修改数据格式不合法"
            Code = Constants.ERROR_CODE_INVALID_PARAMETER
    #print(Success)
    #判断活动type修改后是否有效
    if Success:
        try:
            JudgeResult = JudgeValid.JudgeTypeChangeValid(
                TheActivity.Type, ChangeDictionary["type"],
                TheActivity.StatusGlobal)
            if JudgeResult["result"] != "success":
                Success = False
                Reason = JudgeResult["reason"]
                Code = JudgeResult["code"]
        except:
            Success = False
            Reason = "待修改数据格式不合法"
            Code = Constants.ERROR_CODE_INVALID_PARAMETER
    #判断时间,人数等修改后是否有效
    if Success and WhetherJudgeTime:
        try:
            JudgeResult = JudgeValid.JudgeParameterValid(ChangeDictionary["curTime"], ChangeDictionary["start"], ChangeDictionary["end"], \
            ChangeDictionary["signupBeginAt"], ChangeDictionary["signupStopAt"], ChangeDictionary["curUser"], ChangeDictionary["minUser"], \
            ChangeDictionary["maxUser"])
            if JudgeResult["result"] != "success":
                Success = False
                Reason = JudgeResult["reason"]
                Code = Constants.ERROR_CODE_INVALID_CHANGE
        except:
            Success = False
            Reason = "待修改数据格式不合法"
            Code = Constants.ERROR_CODE_INVALID_PARAMETER
    if Success and ChangeDictionary["maxUser"] != Constants.UNDEFINED_NUMBER:
        try:
            if ChangeDictionary["minUser"] > ChangeDictionary["maxUser"]:
                Success = False
                Reason = "最小人数不能大于最大人数!"
                Code = Constants.ERROR_CODE_INVALID_CHANGE
            if ChangeDictionary["curUser"] > ChangeDictionary["maxUser"]:
                Success = False
                Reason = "当前人数不能大于最大人数!"
                Code = Constants.ERROR_CODE_INVALID_CHANGE
        except:
            Success = False
            Reason = "待修改数据格式不合法"
            Code = Constants.ERROR_CODE_INVALID_PARAMETER
    #判断状态等改后是否有效
    if Success:
        try:
            JudgeResult = JudgeValid.JudgeActivityStatusChangeValid(
                TheActivity.StatusGlobal, ChangeDictionary["statusGlobal"])
            if JudgeResult["result"] != "success":
                Success = False
                Reason = JudgeResult["reason"]
                Code = Constants.ERROR_CODE_INVALID_CHANGE
            if JudgeValid.JudgeActivityStatusJoinValid(
                    ChangeDictionary["statusJoin"]) != True:
                Success = False
                Reason = "待修改的活动加入状态不合法"
                Code = Constants.ERROR_CODE_INVALID_PARAMETER
            if JudgeValid.JudgeActivityStatusCheckValid(
                    ChangeDictionary["statusCheck"]) != True:
                Success = False
                Reason = "待修改的活动签到状态不合法"
                Code = Constants.ERROR_CODE_INVALID_PARAMETER
            if JudgeValid.JudgeRuleTypeValid(
                    ChangeDictionary["ruleType"]) != True:
                Success = False
                Reason = "待修改的活动规则类型不合法!"
                Code = Constants.ERROR_CODE_INVALID_PARAMETER
        except:
            Success = False
            Reason = "待修改数据格式不合法"
            Code = Constants.ERROR_CODE_INVALID_PARAMETER
    #判断高级规则等改后是否有效
    if Success:
        try:
            if ChangeDictionary["rules"] != []:
                JudgeResult = JudgeValid.JudgeAdvancedRuleValid(
                    ChangeDictionary["rules"])
                if JudgeResult["result"] != "success":
                    Success = False
                    Reason = JudgeResult["reason"]
                    Code = Constants.ERROR_CODE_INVALID_CHANGE
        except:
            Success = False
            Reason = "待修改数据格式不合法"
            Code = Constants.ERROR_CODE_INVALID_PARAMETER
    #修改
    #print(Success)
    if Success:
        try:
            TheActivity.Name = ChangeDictionary["name"]
            TheActivity.Place = ChangeDictionary["place"]
            TheActivity.StartTime = ChangeDictionary["start"]
            TheActivity.EndTime = ChangeDictionary["end"]
            TheActivity.SignUpStartTime = ChangeDictionary["signupBeginAt"]
            TheActivity.SignUpEndTime = ChangeDictionary["signupStopAt"]
            TheActivity.MinUser = ChangeDictionary["minUser"]
            TheActivity.MaxUser = ChangeDictionary["maxUser"]
            TheActivity.Type = ChangeDictionary["type"]
            TheActivity.StatusGlobal = ChangeDictionary["statusGlobal"]
            TheActivity.StatusJoin = ChangeDictionary["statusJoin"]
            TheActivity.StatusCheck = ChangeDictionary["statusCheck"]
            TheActivity.CanBeSearched = ChangeDictionary["canBeSearched"]
            TheActivity.GlobalRule = ChangeDictionary["ruleType"]
            TheActivity.Tags = ChangeDictionary["tags"]
            TheActivity.ImageURL = ChangeDictionary["imageUrl"]
            TheActivity.GPSPlace = ChangeDictionary["position"]
            TheActivity.save()

            TheSearcher = SearchAndRecommend.WhooshSearcher.Create()
            TheSearcher.UpdateOneInfo(
                Information["id"], TheActivity.Name + ',' + TheActivity.Tags)
        except:
            Success = False
            Reason = "修改数据失败"
            Code = Constants.ERROR_CODE_UNKNOWN

    if Success:
        try:
            #print(ChangeDictionary["rules"], Information["id"])
            if ChangeDictionary["rules"] != []:
                #修改高级报名规则
                if ChangeAdvancedRules(Information["id"],
                                       ChangeDictionary["rules"]) != True:
                    Success = False
                    Reason = "修改数据失败"
                    Code = Constants.ERROR_CODE_UNKNOWN
        except:
            Success = False
            Reason = "修改数据失败"
            Code = Constants.ERROR_CODE_UNKNOWN

    if Success == False:
        Return["result"] = "fail"
        Return["reason"] = Reason
        Return["code"] = Code
    else:
        Return["result"] = "success"
    return Return
def AuditUser(TheManagerID, TheUserID, TheActivityID, WhetherPass):
	'''
	描述:审核用户
	参数:管理员openid,用户openid,活动id,是否通过(0或1)
	返回:成功{result:success}
		 失败:{result:fail,reason:xxx,code:xxx}
	'''
	Return = {}
	Reason = ""
	Code = 0
	Success = True
	ThePass = -1
	ResultList = []
	if Success:
		try:
			if JudgeValid.JudgeWhetherManager(TheManagerID, TheActivityID) != True:
				Success = False
				Reason = "权限不足,需要是管理员或创建者!"
				Code = Constants.ERROR_CODE_LACK_ACCESS
			TheActivity = Activity.objects.get(ID = TheActivityID)
			TheUser = User.objects.get(OpenID = TheUserID)
		except:
			Success = False
			Reason = "未找到用户或活动!"
			Code = Constants.ERROR_CODE_NOT_FOUND
	if Success:
		if JudgeValid.JudgeActivityNormal(TheActivityID) != True: 
			Success = False
			Reason = "活动状态为异常或结束,不能操作!"
			Code = Constants.ERROR_CODE_INVALID_CHANGE
	if Success:
		try:
			TheJoinActivity = JoinInformation.objects.get(ActivityId = TheActivity, UserId = TheUser)
			TheStatus = TheJoinActivity.Status
			if TheStatus != Constants.USER_STATUS_WAITVALIDATE:
				Success = False
				Reason = "该用户不是待审核状态"
				Code = Constants.ERROR_CODE_INVALID_CHANGE
		except:
			Success = False
			Reason = "用户未参加该活动!"
			Code = Constants.ERROR_CODE_NOT_FOUND
	if Success:
		try:
			ThePass = int(WhetherPass)
			if ThePass != 0 and ThePass != 1:
				Success = False
				Reason = "参数不合法!"
				Code = Constants.ERROR_CODE_INVALID_PARAMETER
		except:
			Success = False
			Reason = "参数不合法!"
			Code = Constants.ERROR_CODE_INVALID_PARAMETER
	if Success:
		try:
			if ThePass == 0:
				TheJoinActivity.Status = Constants.USER_STATUS_REFUSED
				TheJoinActivity.save()
			else:
				if TheActivity.MaxUser != Constants.UNDEFINED_NUMBER and TheActivity.CurrentUser >= TheActivity.MaxUser:
					Success = False
					Reason = "当前人数已满,不能审核通过!"
					Code = Constants.ERROR_CODE_INVALID_CHANGE
				else:
					CurrentTime = GlobalFunctions.GetCurrentTime()
					TheJoinActivity.Status = Constants.USER_STATUS_JOINED
					TheJoinActivity.JoinTime = CurrentTime
					TheJoinActivity.JoinReason = "无"
					TheActivity.CurrentUser = TheActivity.CurrentUser + 1
					TheActivity.save()
					TheJoinActivity.save()
		except:
			Success = False
			Reason = "审核失败!"
			Code = Constants.ERROR_CODE_UNKNOWN
	if Success:
		Return["result"] = "success"
	else:
		Return["result"] = "fail"
		Return["reason"] = Reason
		Return["code"] = Code
	return Return
Пример #25
0
def SendTimedMessage(TheActivityItem, TheUserItem, TheMessageType):
    '''
	描述:推送活动消息函数
	参数: 活动的对象,用户对象,消息类型(作为数字定义在constants.py里)
	返回:无
	'''
    Success = True
    obj = {}
    data = {}
    pagePrefix = "/pages/ActivityList/ActivityDetail/ActivityDetail?activityId="
    if Success:
        try:
            if (TheMessageType == Constants.MESSAGE_TYPE_ACTIVITY_CHANGE
                    or TheMessageType == Constants.MESSAGE_TYPE_KICK
                    or TheMessageType == Constants.MESSAGE_TYPE_ACTIVITY_CANCEL
                    or TheMessageType
                    == Constants.MESSAGE_TYPE_ACTIVITY_FORBIDDEN):
                obj["template_id"] = "LEoLo9UsF2by_4UGypKf2v7YLXeYRRGGjskOa0iJzZY"
                data["thing2"] = {"value": TheActivityItem.Name}
                data["date4"] = {
                    "value":
                    time.strftime("%Y{y}%m{m}%d{d} %H:%M",
                                  time.localtime(
                                      TheActivityItem.StartTime)).format(y='年',
                                                                         m='月',
                                                                         d='日')
                }
                data["thing5"] = {"value": TheActivityItem.Place}
                detail = None
                if (TheMessageType == Constants.MESSAGE_TYPE_KICK):
                    detail = "您被活动主办方踢出了该活动。"
                elif (TheMessageType == Constants.MESSAGE_TYPE_ACTIVITY_CANCEL
                      ):
                    detail = "活动主办方取消了该活动。"
                elif (TheMessageType ==
                      Constants.MESSAGE_TYPE_ACTIVITY_FORBIDDEN):
                    detail = "由于违规行为,该活动已被封禁。"
                elif (TheMessageType == Constants.MESSAGE_TYPE_ACTIVITY_CHANGE
                      ):
                    detail = "活动安排发生了变更。点击可查看详情。"
                data["thing6"] = {"value": detail}
            elif (TheMessageType == Constants.MESSAGE_TYPE_AUDIT_PASS
                  or TheMessageType == Constants.MESSAGE_TYPE_AUDIT_FAIL):
                obj["template_id"] = "j9EPrZx9MAQ5SjbN1aCYHImxymn6ZEziJLgQEcbuXSk"
                data["thing2"] = {"value": TheActivityItem.Name}
                data["date3"] = {
                    "value":
                    time.strftime("%Y{y}%m{m}%d{d} %H:%M",
                                  time.localtime(
                                      TheActivityItem.StartTime)).format(y='年',
                                                                         m='月',
                                                                         d='日')
                }
                if (TheMessageType == Constants.MESSAGE_TYPE_AUDIT_PASS):
                    data["thing7"] = {"value": "您的加入申请已被通过"}
                    data["phrase1"] = {"value": "通过"}
                elif (TheMessageType == Constants.MESSAGE_TYPE_AUDIT_FAIL):
                    data["thing7"] = {"value": "如有疑问请联系活动主办方。"}
                    data["phrase1"] = {"value": "不通过"}
            elif (TheMessageType == Constants.MESSAGE_TYPE_NEW_ACTIVITY_PASS or
                  TheMessageType == Constants.MESSAGE_TYPE_NEW_ACTIVITY_FAIL):
                obj["template_id"] = "j9EPrZx9MAQ5SjbN1aCYHImxymn6ZEziJLgQEcbuXSk"
                data["thing2"] = {"value": TheActivityItem.Name}
                data["date3"] = {
                    "value":
                    time.strftime("%Y{y}%m{m}%d{d} %H:%M",
                                  time.localtime(
                                      TheActivityItem.StartTime)).format(y='年',
                                                                         m='月',
                                                                         d='日')
                }
                if (TheMessageType == Constants.MESSAGE_TYPE_NEW_ACTIVITY_PASS
                    ):
                    data["thing7"] = {"value": "校友总会已审核通过您发起的活动。"}
                    data["phrase1"] = {"value": "通过"}
                elif (TheMessageType ==
                      Constants.MESSAGE_TYPE_NEW_ACTIVITY_FAIL):
                    data["thing7"] = {"value": "校友总会拒绝了您发起的活动。"}
                    data["phrase1"] = {"value": "不通过"}
            elif (TheMessageType ==
                  Constants.MESSAGE_TYPE_ACTIVITY_WILL_START_HOUR):
                obj["template_id"] = "u-UA76noUE9_9g2ZVX53W9DQKz3x-Tn1914KHphfRXM"
                data["thing7"] = {"value": "您报名的活动将在明天举行,请合理安排行程"}
                data["thing4"] = {"value": TheActivityItem.Name}
                data["date3"] = {
                    "value":
                    time.strftime("%Y{y}%m{m}%d{d} %H:%M",
                                  time.localtime(
                                      TheActivityItem.StartTime)).format(y='年',
                                                                         m='月',
                                                                         d='日')
                }
                data["thing6"] = {"value": TheActivityItem.Place}
            elif (TheMessageType ==
                  Constants.MESSAGE_TYPE_ACTIVITY_WILL_START_MINUTE):
                obj["template_id"] = "u-UA76noUE9_9g2ZVX53Wz3QZ-IgE4ECwLVxWLIJlZ8"
                data["thing7"] = {"value": "您报名的活动即将举行,请按时到场并签到"}
                data["thing4"] = {"value": TheActivityItem.Name}
                data["date5"] = {
                    "value":
                    time.strftime("%Y{y}%m{m}%d{d} %H:%M",
                                  time.localtime(
                                      TheActivityItem.StartTime)).format(y='年',
                                                                         m='月',
                                                                         d='日')
                }
                data["thing6"] = {"value": TheActivityItem.Place}
            else:
                Success = False
                Reason = "没有对应的消息类型"
        except:
            Success = False
            Reason = "产生消息阶段异常"

    if Success:
        try:
            obj["touser"] = TheUserItem.OpenID
            obj["page"] = pagePrefix + str(TheActivityItem.ID)
            obj["data"] = data
        except:
            Success = False
            Reason = "产生消息阶段2异常"

    if Success:
        try:
            url = "https://api.weixin.qq.com/cgi-bin/message/subscribe/send?access_token=" + GlobalFunctions.GetAccessToken(
            )
            TheRequest = requests.post(url,
                                       data=json.dumps(obj),
                                       timeout=(5, 10),
                                       allow_redirects=True)
        except:
            Success = False
            ErrorId = Constants.ERROR_CODE_NETWORK_ERROR
            Reason = "网络繁忙,访问超时!"

    if Success:
        try:
            if TheRequest.status_code < 200 or TheRequest.status_code >= 400:
                Success = False
                ErrorId = Constants.ERROR_CODE_NETWORK_ERROR
                Reason = "网络繁忙,访问微信失败!!"
            TheJson = TheRequest.json()
            #print(TheJson)
            if "errcode" in TheJson:
                if TheJson["errcode"] == -1:
                    Success = False
                    ErrorId = Constants.ERROR_CODE_NETWORK_ERROR
                    Reason = "网络繁忙,访问微信失败!"
                elif TheJson["errcode"] != 0:
                    Success = False
                    ErrorId = Constants.ERROR_CODE_NETWORK_ERROR
                    Reason = TheJson["errmsg"]
        except:
            Success = False
            ErrorId = Constants.ERROR_CODE_NETWORK_ERROR
            Reason = "网络繁忙,访问微信失败!"

    return Success
def CheckInActivity(TheUserID, TheActivityID, TheCode, TheDistance):
	'''
	描述:用户签到
	参数:用户openid,活动id,二维码code, 距离
	返回:成功{result:success}
		 失败:{result:fail,reason:xxx,code:xxx}
	'''
	Return = {}
	Reason = ""
	Code = 0
	Success = True
	ThePass = -1
	ResultList = []
	if Success:
		try:
			TheActivity = Activity.objects.get(ID = TheActivityID)
			TheUser = User.objects.get(OpenID = TheUserID)

			if TheCode != None:
				if TheCode != TheActivity.Code:
					Success = False
					Reason = "二维码和活动不匹配!"
					Code = Constants.ERROR_CODE_INVALID_CHANGE
			elif TheDistance != None:
				if TheDistance > Constants.SUCCESS_THRESHOLD:
					Success = False
					Reason = "距离太远,签到失败!"
					Code = Constants.ERROR_CODE_INVALID_CHANGE
			else:
				Success = False
				Reason = "请求参数不合法!"
				Code = Constants.ERROR_CODE_INVALID_PARAMETER
		except:
			Success = False
			Reason = "未找到用户或活动!"
			Code = Constants.ERROR_CODE_NOT_FOUND
	if Success:
		if JudgeValid.JudgeActivityNormal(TheActivityID) != True: 
			Success = False
			Reason = "活动状态为异常或结束,不能操作!"
			Code = Constants.ERROR_CODE_INVALID_CHANGE
	if Success:
		try:
			TheJoinActivity = JoinInformation.objects.get(ActivityId = TheActivity, UserId = TheUser)
			TheStatus = TheJoinActivity.Status
			TheRole = TheJoinActivity.Role
			if JudgeValid.JudgeUserStatusDoingActivity(TheStatus) != True:
				Success = False
				Reason = "该用户不是活动正式成员"
				Code = Constants.ERROR_CODE_INVALID_CHANGE
			elif TheStatus == Constants.USER_STATUS_CHECKED:
				Success = False
				Reason = "该用户已经签到!"
				Code = Constants.ERROR_CODE_INVALID_CHANGE
		except:
			Success = False
			Reason = "用户未参加该活动!"
			Code = Constants.ERROR_CODE_NOT_FOUND
		#判断状态是否可行
		if Success:
			if JudgeValid.JudgeActivityCanCheck(TheActivityID)!= True:
				Success = False
				Reason = "当前活动不在可以签到状态,可能签到未开始,已暂停或已经截止"
				Code = Constants.ERROR_CODE_INVALID_CHANGE
	if Success:
		try:
			TheCheckTime = GlobalFunctions.GetCurrentTime()
			TheJoinActivity.CheckTime = TheCheckTime
			TheJoinActivity.Status = Constants.USER_STATUS_CHECKED
			TheJoinActivity.save()
		except:
			Success = False
			Reason = "签到失败!"
			Code = Constants.ERROR_CODE_UNKNOWN
	if Success:
		Return["result"] = "success"
	else:
		Return["result"] = "fail"
		Return["reason"] = Reason
		Return["code"] = Code
	return Return
Пример #27
0
def ShowAllUsers(TheLastSeenID, TheMostNumber):
	'''
	描述:查询所有用户
	参数: 最后一个id,最多显示的数目
	返回:第一个是一个字典,里面就一个字典数组userList,字典每个字典有用户具体信息,失败为空
		 第二个是失败状态信息,成功是空,失败有reason和code	
	'''
	#查询
	Success = True
	if Success:
		try:
			Info =	User.objects.all()
		except:
			Success = False
	#处理数据并且返回
	Return = {}
	ErrorInfo = {}
	Result = []
	#print(TheLastID, TheMostNumber)
	if Success:
		try:
			CurrentNumber = 0
			i = len(Info) - 1
			while i >= 0:
				item = Info[i]
				if TheLastSeenID != Constants.UNDEFINED_NUMBER:
					if item.ID >= TheLastSeenID:
						i -= 1
						continue
				TheResult = {}
				TheResult["id"] = item.ID
				TheResult["name"] = item.Name
				TheResult["openId"] = item.OpenID
				TheResult["avatarUrl"] = GlobalFunctions.GetTrueAvatarUrlUser(item.AvatarURL)
				TheResult["status"] = item.Status
				TheResult["extraData"] = item.ExtraData
				TheResult["point"] = item.Point
				TheEducation = []
				TheEducationInfo = item.Education.all()
				for oneEducation in TheEducationInfo:
					OneResult = {}
					OneResult["enrollmentYear"] = oneEducation.StartYear
					OneResult["department"] = oneEducation.Department
					OneResult["enrollmentType"] = oneEducation.Type
					TheEducation.append(OneResult)
				TheResult["campusIdentity"] = TheEducation
				Result.append(TheResult)
				CurrentNumber = CurrentNumber + 1
				if TheMostNumber != Constants.UNDEFINED_NUMBER and CurrentNumber >= TheMostNumber:
					break
				i -= 1
		except:
			Success = False
	if Success == True:
		Return["userList"] = Result
		ErrorInfo = {}
	else:
		Return = {}
		ErrorInfo["reason"] = "查询用户失败!"
		ErrorInfo["code"] = Constants.ERROR_CODE_UNKNOWN
	return Return, ErrorInfo
Пример #28
0
def ShowOneActivity(TheActivityID):
	'''
	描述:给定活动id,查询活动具体信息
	参数:用户id和活动id
	返回:一个字典,里面有活动各种信息,错误信息
	成功:错误信息空
	失败:返回字典空,错误信息存在
	'''
	Success = True
	Result = {}
	ErrorInfo = {}
	Reason = ""
	Code = 0
	if Success:
		try:
			TheActivity = Activity.objects.get(ID = TheActivityID)
		except:
			Success = False
			Reason = "未找到该活动!"
			Code = Constants.ERROR_CODE_NOT_FOUND

	if Success:
		Result = ActivityManager.QueryActivity(TheActivityID)
		if Result == {}:
			Success = False
			Reason = "查询活动失败!"
			Code = Constants.ERROR_CODE_UNKNOWN

	if Success:
		if 1:
			Result["position"] = TheActivity.GPSPlace
			TheJoinActivityList = JoinInformation.objects.filter(ActivityId = TheActivity)
			Result["participants"] = []
			NumberNeedAudit = 0
			for item in TheJoinActivityList:
				TheUserInfo = {}
				TheId = item.UserId.OpenID
				TheStatus = item.Status
				TheUserInfo["openId"] = TheId
				TheUserInfo["name"] = item.UserId.Name
				TheUserInfo["avatarUrl"] = GlobalFunctions.GetTrueAvatarUrlUser(item.UserId.AvatarURL)
				TheUserInfo["userStatus"] = TheStatus
				TheUserInfo["userRole"] = item.Role
				TheUserInfo["point"] = item.UserId.Point
				if JudgeValid.JudgeUserStatusJoined(TheStatus):
					Result["participants"].append(TheUserInfo)
				if item.Role == Constants.USER_ROLE_CREATOR:
					Result["creator"] = TheId
				if item.Status == Constants.USER_STATUS_WAITVALIDATE:
					NumberNeedAudit += 1
			Result["needAuditCount"] = NumberNeedAudit
		else:
			Success = False
			Reason = "查询活动失败!"
			Code = Constants.ERROR_CODE_UNKNOWN

	if Success:
		try:
			TheReportActivityList = ReportInformation.objects.filter(ActivityId = TheActivity)
			Result["reporters"] = []
			for item in TheReportActivityList:
				TheUserInfo = {}
				TheUserInfo["openId"] = item.UserId.OpenID
				TheUserInfo["name"] = item.UserId.Name
				TheUserInfo["avatarUrl"] = GlobalFunctions.GetTrueAvatarUrlUser(item.UserId.AvatarURL)
				TheUserInfo["submitMsg"] = item.Reason
				TheUserInfo["submitTime"] = GlobalFunctions.TimeStampToTimeString(item.SubmitTime)
				Result["reporters"].append(TheUserInfo)
			Result["reportCount"] = len(Result["reporters"])
		except:
			Success = False
			Reason = "查询活动失败!"
			Code = Constants.ERROR_CODE_UNKNOWN

	if Success:
		try:	
			Result["rules"] = {}
			Result["rules"] = ActivityManager.ShowAllAdvancedRules(TheActivityID)
			Result["rules"]["ruleType"] = TheActivity.GlobalRule
		except:
			Success = False
			Reason = "查询活动失败!"
			Code = Constants.ERROR_CODE_UNKNOWN
	if Success:
		return Result, {}
	else:
		ErrorInfo["reason"] = Reason
		ErrorInfo["code"] = Code
		return {}, ErrorInfo
Пример #29
0
def ShowAllActivity(TheLastID, TheMostNumber):
	'''
	描述:查询所有活动
	参数: 最后一个id,最多显示的数目
	返回:第一个是一个字典,里面就一个字典数组activityList,字典每个字典有活动具体信息,失败为空
		 第二个是失败状态信息,成功是空,失败有reason和code	'''
	#查询
	Success = True
	if Success:
		try:
			Info = Activity.objects.all()
		except:
			Success = False
	#处理数据并且返回
	Return = {}
	ErrorInfo = {}
	Result = []
	#print(TheLastID, TheMostNumber)
	if Success:
		try:
			CurrentNumber = 0
			i = len(Info) - 1
			while i >= 0:
				item = Info[i]
				if TheLastID != Constants.UNDEFINED_NUMBER:
					if item.ID >= TheLastID:
						i -= 1
						continue
				TheResult = {}
				TheResult["id"] = item.ID
				TheResult["name"] = item.Name
				TheResult["place"] = item.Place
				TheResult["createTime"] = GlobalFunctions.TimeStampToTimeString(int(item.CreateTime))
				TheResult["start"] = GlobalFunctions.TimeStampToTimeString(int(item.StartTime))
				TheResult["end"] = GlobalFunctions.TimeStampToTimeString(int(item.EndTime))
				TheResult["signupBeginAt"] = GlobalFunctions.TimeStampToTimeString(int(item.SignUpStartTime))
				TheResult["signupStopAt"] = GlobalFunctions.TimeStampToTimeString(int(item.SignUpEndTime))
				TheResult["minUser"] = int(item.MinUser)
				TheResult["maxUser"] = int(item.MaxUser)
				TheResult["curUser"] = int(item.CurrentUser)
				TheResult["type"] = item.Type
				TheResult["statusGlobal"] = int(item.StatusGlobal)
				TheResult["statusJoin"] = int(item.StatusJoin)
				TheResult["statusCheck"] = int(item.StatusCheck)
				TheResult["tags"] = GlobalFunctions.SplitTags(item.Tags)
				TheResult["imageUrl"] = GlobalFunctions.GetTrueAvatarUrlActivity(item.ImageURL)
				TheReportActivityList = ReportInformation.objects.filter(ActivityId = item)
				TheResult["reportCount"] = len(TheReportActivityList)
				Result.append(TheResult)
				CurrentNumber = CurrentNumber + 1
				if TheMostNumber != Constants.UNDEFINED_NUMBER and CurrentNumber >= TheMostNumber:
					break
				i -= 1
		except:
			Success = False
	if Success == True:
		Return["activityList"] = Result
		ErrorInfo = {}
	else:
		Return = {}
		ErrorInfo["reason"] = "查询活动失败!"
		ErrorInfo["code"] = Constants.ERROR_CODE_UNKNOWN
	return Return, ErrorInfo
Пример #30
0
def QueryEducationTypes(request):
    '''
    描述:处理查询所有教育类型
    参数:request
    成功返回全部教育类型
    失败则是
    {
    "errid":xxx,
    "errmsg":"xxxx"
    }
    '''
    Success = True
    Return = {}
    Info = {}
    Reason = ""
    ErrorID = Constants.UNDEFINED_NUMBER
    TheSession = ""
    TheUserID = ""
    #获取请求数据
    if Success:
        try:
            TheSession = request.GET.get("session")
        except:
            Success = False
            Reason = "请求参数不合法!"
            ErrorID = Constants.ERROR_CODE_INVALID_PARAMETER

    #判断是否登录,获取待查询的openid
    if Success:
        try:
            TheUserID = UserManager.GetCurrentUser(TheSession)
            if TheUserID == None:
                Success = False
                Reason = "用户未登录!"
                ErrorID = Constants.ERROR_CODE_LOGIN_ERROR
        except:
            Success = False
            Reason = "用户未登录!"
            ErrorID = Constants.ERROR_CODE_LOGIN_ERROR

    #调用数据库函数
    if Success:
        try:
            Info = GlobalFunctions.ShowAllEducationType()
            #print(Info)
            if Info == {}:
                Success = False
                Reason = "查询教育类型列表失败!"
                ErrorID = Constants.ERROR_CODE_NOT_FOUND
        except:
            Success = False
            Reason = "查询教育类型列表失败!"
            ErrorID = Constants.ERROR_CODE_NOT_FOUND

    if Success:
        Return = Info
    else:
        Return["errid"] = ErrorID
        Return["errmsg"] = Reason
    Response = JsonResponse(Return)
    if Success == True:
        Response.status_code = 200
    else:
        Response.status_code = 400
    return Response