def RemoveRefuseActivity(TheUserID, TheActivityList):
'''
描述：移除用户参与必定被拒绝的活动
参数: 用户openid，活动列表
返回：新的活动列表，失败返回空列表
'''
Success = True
Return = {}
NewActivityList = []
if Success:
try:
TheUser = User.objects.get(OpenID=TheUserID)
except:
Success = False
if Success:
try:
for item in TheActivityList["activityList"]:
TheActivityID = int(item["id"])
WhetherCanJoin = JudgeValid.JudgeWhetherCanJoinAdvanced(
TheUserID, TheActivityID)
WhetherFull = JudgeValid.JudgeWhetherFull(TheActivityID)
if WhetherCanJoin != Constants.UNDEFINED_NUMBER and WhetherFull == False:
NewActivityList.append(item)
except:
Success = False
if Success:
Return["activityList"] = NewActivityList
else:
Return = {}
return Return
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 SearchBruteForce(self, TheKeyWord):
'''
描述：暴力匹配搜索
参数: 关键词
返回：搜索结果列表
'''
Success = True
TheList = []
if Success:
try:
TheActivityList = Activity.objects.all()
except:
Success = False
print(Success)
if Success:
try:
i = len(TheActivityList) - 1
while i >= 0:
item = TheActivityList[i]
if JudgeValid.JudgeActivityCanBeSearched(item.ID):
TheKey = re.compile(TheKeyWord)
MatchResult = TheKey.search(item.Name + ',' +
item.Tags)
print(MatchResult)
if MatchResult:
TheInfo = self.GetOneActivityInfo(item.ID)
if TheInfo != {}:
TheList.append(TheInfo)
i -= 1
except:
Success = False
if Success:
return TheList
else:
return []
def RemoveJoinedActivity(TheUserID, TheActivityList):
'''
描述：移除用户参与过的活动
参数: 用户openid，活动列表
返回：新的活动列表，失败返回空列表
'''
Success = True
Return = {}
NewActivityList = []
if Success:
try:
TheUser = User.objects.get(OpenID=TheUserID)
except:
Success = False
if Success:
try:
for item in TheActivityList["activityList"]:
TheActivityID = int(item["id"])
#print(TheUserID, TheActivityID)
if JudgeValid.JudgeUserJoinedActivity(TheUserID,
TheActivityID) != True:
NewActivityList.append(item)
except:
Success = False
if Success:
Return["activityList"] = NewActivityList
else:
Return = {}
return Return
def ChangeActivityStatus(TheInfo):
'''
描述：修改活动状态
参数: 字典，存储待修改活动状态
返回：成功 success，如果需要返回模板信息就返回"sendMessage":"forbid/pass/fail(都是数值）”，失败 fail+code+reason
'''
Success = True
Reason = ""
Code = 0
TheActivityID = 0
Return = {}
OriginalStatusGlobal = -1
NewStatusGlobal = -1
if Success:
try:
TheActivityID = TheInfo["id"]
TheActivity = Activity.objects.get(ID = TheActivityID)
except:
Success = False
Reason = "活动不存在！"
Code = Constants.ERROR_CODE_NOT_FOUND
if Success:
try:
if "statusGlobal" in TheInfo:
if JudgeValid.JudgeActivityStatusGlobalValid(TheInfo["statusGlobal"]) != True:
Success = False
Reason = "活动全局状态不合法！"
Code = Constants.ERROR_CODE_INVALID_PARAMETER
else:
OriginalStatusGlobal = TheActivity.StatusGlobal
NewStatusGlobal = TheInfo["statusGlobal"]
TheActivity.StatusGlobal = TheInfo["statusGlobal"]
else:
Success = False
Reason = "修改参数不合法！"
Code = Constants.ERROR_CODE_INVALID_PARAMETER
TheActivity.save()
except:
Success = False
Reason = "修改参数不合法！"
Code = Constants.ERROR_CODE_INVALID_PARAMETER
#返回模板消息
if Success:
if OriginalStatusGlobal == Constants.ACTIVITY_STATUS_GLOBAL_NORMAL \
and NewStatusGlobal == Constants.ACTIVITY_STATUS_GLOBAL_EXCEPT:
Return["sendMessage"] = Constants.MESSAGE_TYPE_ACTIVITY_FORBIDDEN
elif OriginalStatusGlobal == Constants.ACTIVITY_STATUS_GLOBAL_AUDIT \
and NewStatusGlobal == Constants.ACTIVITY_STATUS_GLOBAL_NORMAL:
Return["sendMessage"] = Constants.MESSAGE_TYPE_AUDIT_PASS
elif OriginalStatusGlobal == Constants.ACTIVITY_STATUS_GLOBAL_AUDIT \
and NewStatusGlobal == Constants.ACTIVITY_STATUS_GLOBAL_EXCEPT:
Return["sendMessage"] = Constants.MESSAGE_TYPE_AUDIT_FAIL
if Success:
Return["result"] = "success"
else:
Return["result"] = "fail"
Return["reason"] = Reason
Return["code"] = Code
return Return
def DeleteActivity(TheUserID, TheActivityID):
'''
描述：删除活动函数（事实是将活动设置为异常，不可见）
参数：活动id
返回：成功True 失败False
'''
Success = True
Result = {}
Reason = ""
Code = Constants.UNDEFINED_NUMBER
if Success:
try:
TheUser = User.objects.get(OpenID=TheUserID)
TheActivity = Activity.objects.get(ID=TheActivityID)
if JudgeValid.JudgeWhetherCreator(TheUserID,
TheActivityID) != True:
Success = False
Reason = "没有权限,只有管理员才能删除活动！！"
Code = Constants.ERROR_CODE_LACK_ACCESS
except:
Success = False
Code = Constants.ERROR_CODE_NOT_FOUND
Reason = "未找到该活动！"
if Success:
if JudgeValid.JudgeActivityNormal(TheActivityID) != True:
Success = False
Reason = "活动状态为异常或结束，不能操作！"
Code = Constants.ERROR_CODE_INVALID_CHANGE
if TheActivity.StatusCheck != Constants.ACTIVITY_STATUS_CHECK_BEFORE:
Success = False
Reason = "签到已经开始，不能删除活动！"
Code = Constants.ERROR_CODE_INVALID_CHANGE
if Success:
TheActivity.StatusGlobal = Constants.ACTIVITY_STATUS_GLOBAL_EXCEPT
TheActivity.save()
TheSearcher = SearchAndRecommend.WhooshSearcher.Create()
TheSearcher.DeleteOneInfo(TheActivityID)
if Success == True:
Result["result"] = "success"
else:
Result["result"] = "fail"
Result["reason"] = Reason
Result["code"] = Code
return Result
def ChangeUserRole(SelfID, TheUserID, TheActivityID, NewRole):
'''
描述：修改用户的权限信息
参数：自己的openid，待修改用户id，活动id，用户新角色
返回：{result：success}/{result：fail，reason：xxx, code:xxx}
权限的话，创建者不能变别的，别的也不能变创建者,只有创建者能把其他人设置成管理员或取消管理员
'''
Success = True
Result = {}
Reason = ""
Code = Constants.UNDEFINED_NUMBER
if Success:
try:
TheSelf = User.objects.get(OpenID = SelfID)
TheUser = User.objects.get(OpenID = TheUserID)
TheActivity = Activity.objects.get(ID = TheActivityID)
TheSelfJoinInformation = JoinInformation.objects.get(UserId = TheSelf, ActivityId = TheActivity)
TheUserJoinInformation = JoinInformation.objects.get(UserId = TheUser, ActivityId = TheActivity)
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:
SelfRole = TheSelfJoinInformation.Role
if SelfRole != Constants.USER_ROLE_CREATOR:
Success = False
Reason = "只有创建者才能设置和取消管理员！"
Code = Constants.ERROR_CODE_NOT_FOUND
except:
Success = False
Reason = "请求参数不合法！"
Code = Constants.ERROR_CODE_INVALID_PARAMETER
if Success:
try:
OldRole = TheUserJoinInformation.Role
if OldRole == Constants.USER_ROLE_CREATOR or NewRole == Constants.USER_ROLE_CREATOR:
Success = False
Reason = "不能变更该活动的创建者！"
Code = Constants.ERROR_CODE_INVALID_CHANGE
TheUserJoinInformation.Role = NewRole
TheUserJoinInformation.save()
except:
Success = False
Reason = "请求参数不合法！"
Code = Constants.ERROR_CODE_INVALID_PARAMETER
if Success:
Result["result"] = "success"
else:
Result["result"] = "fail"
Result["reason"] = Reason
Result["code"] = Code
return Result
def ChangeActivityDetail(TheUserID, TheActivityID, Information):
'''
描述：修改活动详情
参数：用户openid，活动id，待修改信息
返回：{result：success}/{result：fail，reason：xxx, code:xxx}
'''
Success = True
Return = {}
Reason = ""
Code = Constants.UNDEFINED_NUMBER
#判断是否能找到这个活动
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
Reason = "没有修改权限"
Code = Constants.ERROR_CODE_LACK_ACCESS
if Success:
if JudgeValid.JudgeActivityNormal(TheActivityID) != True:
Success = False
Reason = "活动状态为异常或结束，不能操作！"
Code = Constants.ERROR_CODE_INVALID_CHANGE
if Success:
try:
TheDescription = Information["description"]
TheActivity.Description = TheDescription
TheActivity.save()
except:
Success = False
Reason = "参数不合法，修改失败！"
Code = Constants.ERROR_CODE_INVALID_PARAMETER
if Success == False:
Return["result"] = "fail"
Return["reason"] = Reason
Return["code"] = Code
else:
Return["result"] = "success"
return Return
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 LoadDatabaseInfo(self):
'''
描述：从数据库里读取现有的信息用于搜索推荐
参数：无
返回：无
'''
Info = Activity.objects.all()
Writer = self.Index.writer()
for item in Info:
if JudgeValid.JudgeActivityNormal(item.ID):
Writer.add_document(path="/" + str(item.ID),
content=item.Name + item.Tags)
Writer.commit()
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
def GetUserExtraData(TheSelfID, TheUserID, TheActivityID):
'''
描述：查询用户的补充信息
参数：自身openid，用户openid，活动id
返回：符合条件带extraData，不符合条件或者失败是空字典
'''
Return = {}
try:
TheUser = User.objects.get(OpenID=TheUserID)
if TheSelfID == TheUserID:
Return["extraData"] = TheUser.ExtraData
else:
TheActivity = Activity.objects.get(ID=TheActivityID)
if JudgeValid.JudgeWhetherManager(TheSelfID, TheActivityID):
Return["extraData"] = TheUser.ExtraData
except:
pass
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
def GetSelfActivityRelation(TheUserID, TheActivityID):
'''
描述：给定用户openid和活动id，判断用户是否参加了这个活动，以及是否能报名参加
参数：用户openid，活动id
返回：正确：return返回selfstatus，selfrole等,errorinfo为空。错误return为空，errorinfo返回错误id和错误码
'''
Success = True
Return = {}
ErrorInfo = {}
Code = 0
Reason = ""
if Success:
try:
Info = []
TheUser = User.objects.get(OpenID = TheUserID)
TheActivity = Activity.objects.get(ID = TheActivityID)
except:
Success = False
Code = Constants.ERROR_CODE_NOT_FOUND
Reason = "未找到用户或活动！"
if Success:
try:
Info = JoinInformation.objects.get(UserId = TheUser, ActivityId = TheActivity)
Return["selfStatus"] = Info.Status
Return["selfRole"] = Info.Role
except:
Return["selfStatus"] = Constants.UNDEFINED_NUMBER
Return["selfRole"] = Constants.UNDEFINED_NUMBER
WhetherCanJoin = JudgeValid.JudgeWhetherCanJoinAdvanced(TheUserID, TheActivityID)
if WhetherCanJoin == Constants.UNDEFINED_NUMBER:
Return["ruleForMe"] = "reject"
elif WhetherCanJoin == Constants.USER_STATUS_WAITVALIDATE:
Return["ruleForMe"] = "needAudit"
else:
Return["ruleForMe"] = "accept"
if Success:
ErrorInfo = {}
else:
Return = {}
ErrorInfo["reason"] = Reason
ErrorInfo["code"] = Code
return Return, ErrorInfo
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 {}
def UploadActivityQRCode(request):
'''
描述：处理更新活动二维码请求
参数：request
成功返回
{
图片
}
失败则是
{
"errid":xxx,
"errmsg":"xxxx"
}
'''
Success = True
Return = {}
Info = {}
Reason = ""
TheImageName = ""
TheImage = None
ErrorID = Constants.UNDEFINED_NUMBER
TheSession = ""
TheActivity = Constants.UNDEFINED_NUMBER
TheUserID = ""
#获取请求数据
if Success:
try:
TheSession = request.GET.get("session")
TheActivity = int(request.GET.get("activityId"))
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:
JudgeResult = JudgeValid.JudgeUserValid(TheUserID)
if JudgeResult != True:
Success = False
Reason = "用户已被封禁，不能操作！！"
ErrorID = Constants.ERROR_CODE_INVALID_CHANGE
#调用数据库函数
if Success:
try:
Info, TheImageName = ActivityManager.UploadActivityQRCode(
TheUserID, TheActivity)
#print(Info)
if Info["result"] != "success":
Success = False
Reason = Info["reason"]
ErrorID = Info["code"]
except:
Success = False
Reason = "更新活动二维码失败！"
ErrorID = Constants.ERROR_CODE_NOT_FOUND
if Success:
TheImage = open(TheImageName, "rb").read()
Response = HttpResponse(TheImage, content_type="image/png")
else:
Return["errid"] = ErrorID
Return["errmsg"] = Reason
Response = JsonResponse(Return)
if Success == True:
Response.status_code = 200
else:
Response.status_code = 400
return Response
def ChangeActivityDetail(request):
'''
描述：处理修改活动请求
参数：request
成功只返回
{
"result": "success"
}
失败则是
{
"errid":xxx,
"errmsg":"xxxx"
}
'''
Success = True
Return = {}
Reason = ""
ErrorID = Constants.UNDEFINED_NUMBER
TheSession = ""
TheActivity = 0
TheUserID = ""
Data = {}
#获取请求数据
if Success:
try:
TheSession = request.GET.get("session")
TheActivity = int(request.GET.get("activityId"))
Data = json.loads(request.body)
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:
JudgeResult = JudgeValid.JudgeUserValid(TheUserID)
if JudgeResult != True:
Success = False
Reason = "用户已被封禁，不能操作！！"
ErrorID = Constants.ERROR_CODE_INVALID_CHANGE
#调用数据库函数
if Success:
try:
Info = ActivityManager.ChangeActivityDetail(
TheUserID, TheActivity, Data)
if Info["result"] != "success":
Success = False
Reason = Info["reason"]
ErrorID = Info["code"]
except:
Success = False
Reason = "修改活动详情失败"
ErrorID = Constants.ERROR_CODE_UNKNOWN
if Success:
Return["result"] = "success"
else:
Return["errmsg"] = Reason
Return["errid"] = ErrorID
Response = JsonResponse(Return)
if Success == True:
Response.status_code = 200
else:
Response.status_code = 400
return Response
def ChangeActivity(request):
'''
描述：处理修改活动请求
参数：request
成功只返回
{
"result": "success"
}
失败则是
{
"errid":xxx,
"errmsg":"xxxx"
}
'''
Success = True
Return = {}
Reason = ""
ErrorID = Constants.UNDEFINED_NUMBER
TheSession = ""
TheUserID = ""
Data = {}
NeedPush = False
#获取请求数据
if Success:
try:
TheSession = request.GET.get("session")
Data = json.loads(request.body)
try:
TheNeedPush = request.GET.get("needPush")
if int(TheNeedPush) > 0:
NeedPush = True
except:
NeedPush = False
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:
JudgeResult = JudgeValid.JudgeUserValid(TheUserID)
if JudgeResult != True:
Success = False
Reason = "用户已被封禁，不能操作！！"
ErrorID = Constants.ERROR_CODE_INVALID_CHANGE
#调用数据库函数
if Success:
try:
Info = ActivityManager.ChangeActivity(TheUserID, Data)
if Info["result"] != "success":
Success = False
Reason = Info["reason"]
ErrorID = Info["code"]
except:
Success = False
Reason = "修改活动失败"
ErrorID = Constants.ERROR_CODE_UNKNOWN
if Success:
Return["result"] = "success"
else:
Return["errmsg"] = Reason
Return["errid"] = ErrorID
Response = JsonResponse(Return)
if Success == True:
Response.status_code = 200
else:
Response.status_code = 400
#发送消息
if Success and NeedPush:
TimeManager.SendTimedMessageActivity(
Data["id"], Constants.MESSAGE_TYPE_ACTIVITY_CHANGE)
print("send change")
return Response
def DeleteActivity(request):
'''
描述：处理删除单个活动信息请求
参数：request
成功返回
{
"result": "success"
}
失败则是
{
"errid":xxx,
"errmsg":"xxxx"
}
'''
Success = True
Return = {}
Info = {}
Reason = ""
ErrorID = Constants.UNDEFINED_NUMBER
TheSession = ""
TheActivity = Constants.UNDEFINED_NUMBER
TheUserID = ""
#获取请求数据
if Success:
try:
TheSession = request.GET.get("session")
TheActivity = int(request.GET.get("activityId"))
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:
JudgeResult = JudgeValid.JudgeUserValid(TheUserID)
if JudgeResult != True:
Success = False
Reason = "用户已被封禁，不能操作！！"
ErrorID = Constants.ERROR_CODE_INVALID_CHANGE
#调用数据库函数
if Success:
try:
Info = ActivityManager.DeleteActivity(TheUserID, TheActivity)
#print(Info)
if Info["result"] != "success":
Success = False
Reason = Info["reason"]
ErrorID = Info["code"]
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
if Success:
TimeManager.SendTimedMessageActivity(
TheActivity, Constants.MESSAGE_TYPE_ACTIVITY_CANCEL)
print("send cancel")
return Response
def RemoveFromActivity(request):
'''
描述：将用户踢出活动
参数：request
返回：成功{result：success}
失败：{result：fail，errmsg：xxx，errid：xxx}
'''
Success = True
Return = {}
Reason = ""
ErrorID = Constants.UNDEFINED_NUMBER
TheSession = ""
TheManagerID = ""
TheUserID = ""
TheActivityID = -1
WhetherPass = ""
#获取请求数据
if Success:
try:
TheSession = request.GET.get("session")
TheUserID = request.GET.get("userId")
TheActivityID = int(request.GET.get("activityId"))
except:
Success = False
Reason = "请求参数不合法！"
ErrorID = Constants.ERROR_CODE_INVALID_PARAMETER
#判断是否登录， 获取待查询的openid
if Success:
try:
TheManagerID = UserManager.GetCurrentUser(TheSession)
if TheManagerID == None:
Success = False
Reason = "用户未登录！"
ErrorID = Constants.ERROR_CODE_LOGIN_ERROR
except:
Success = False
Reason = "用户未登录！"
ErrorID = Constants.ERROR_CODE_LOGIN_ERROR
#判断是否被封禁
if Success:
JudgeResult = JudgeValid.JudgeUserValid(TheManagerID)
if JudgeResult != True:
Success = False
Reason = "用户已被封禁，不能操作！！"
ErrorID = Constants.ERROR_CODE_INVALID_CHANGE
#调用数据库函数
if Success:
try:
Info = UserActivityManager.RemoveUser(TheManagerID, TheUserID,
TheActivityID)
if Info["result"] != "success":
Success = False
Reason = Info["reason"]
ErrorID = Info["code"]
except:
Success = False
Reason = "将用户移出活动失败"
ErrorID = Constants.ERROR_CODE_UNKNOWN
if Success:
Return["result"] = "success"
else:
Return["errmsg"] = Reason
Return["errid"] = ErrorID
Response = JsonResponse(Return)
if Success == True:
Response.status_code = 200
else:
Response.status_code = 400
if Success:
TimeManager.SendTimedMessageUser(TheActivityID, TheUserID,
Constants.MESSAGE_TYPE_KICK)
print("send kick")
return Response
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
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
def RemoveUser(TheManagerID, TheUserID, TheActivityID):
'''
描述：将用户踢出活动
参数：管理员openid，用户openid，活动id
返回：成功{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)
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
except:
Success = False
Reason = "用户未参加该活动！"
Code = Constants.ERROR_CODE_NOT_FOUND
if Success:
if TheRole == Constants.USER_ROLE_CREATOR:
Success = False
Reason = "不能将创建者踢出活动！"
Code = Constants.ERROR_CODE_INVALID_CHANGE
elif TheRole == Constants.USER_ROLE_MANAGER:
if JudgeValid.JudgeWhetherCreator(TheManagerID, TheActivityID) != True:
Success = False
Reason = "权限不足，只有创建者能把管理员踢出活动！"
Code = Constants.ERROR_CODE_LACK_ACCESS
else:
if JudgeValid.JudgeWhetherManager(TheManagerID, TheActivityID) != True:
Success = False
Reason = "权限不足，需要是管理员或创建者！"
Code = Constants.ERROR_CODE_LACK_ACCESS
if Success:
try:
TheJoinActivity.Role = Constants.USER_ROLE_COMMONER
TheJoinActivity.Status = Constants.USER_STATUS_REFUSED
TheActivity.CurrentUser = TheActivity.CurrentUser - 1
TheJoinActivity.save()
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
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
def JoinActivity(TheUserID, TheActivityID, TheJoinReason):
'''
描述：报名函数
参数：用户id，活动id,报名原因（没有就是None）
返回：成功{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:
if JudgeValid.JudgeUserJoinedActivity(TheUserID, TheActivityID) == True:
Success = False
Reason = "已经加入了"
Code = Constants.ERROR_CODE_INVALID_CHANGE
if Success:
#判断人数是否可行
if TheActivity.MaxUser != Constants.UNDEFINED_NUMBER and TheActivity.CurrentUser >= TheActivity.MaxUser:
Success = False
Reason = "活动人数已满"
Code = Constants.ERROR_CODE_INVALID_CHANGE
#判断状态是否可行
if Success:
if JudgeValid.JudgeActivityCanJoin(TheActivityID) != True:
Success = False
Reason = "当前活动不在可以报名状态，可能报名未开始，已暂停或已经截止"
Code = Constants.ERROR_CODE_INVALID_CHANGE
#判断高级选项
if Success:
TheStatus = JudgeValid.JudgeWhetherCanJoinAdvanced(TheUserID, TheActivityID)
if TheStatus == Constants.UNDEFINED_NUMBER:
Success = False
Reason = "不符合报名条件"
Code = Constants.ERROR_CODE_REJECT
elif TheStatus != Constants.USER_STATUS_WAITVALIDATE:
#直接加入，不需要条件
TheJoinReason = None
else:
#待审核没有reason不行
if TheJoinReason == None or len(TheJoinReason) == 0:
Success = False
Reason = "未输入报名原因！"
Code = Constants.ERROR_CODE_NO_REASON
#加入
#print(TheStatus, Success)
if Success:
Return = AddUserActivity(TheUserID, TheActivityID, TheStatus, TheRole, TheJoinReason)
else:
Return["result"] = "fail"
Return["reason"] = Reason
Return["code"] = Code
#print(Return)
return Return
def CheckInActivity(request):
'''
描述：处理签到活动请求
参数：request
成功只返回
{
"result": "success"
}
失败则是
{
"errid":xxx,
"errmsg":"xxxx"
}
'''
Success = True
Return = {}
Reason = ""
ErrorID = Constants.UNDEFINED_NUMBER
TheSession = ""
TheActivity = Constants.UNDEFINED_NUMBER
TheUserID = ""
TheJoinReason = None
#获取请求数据
if Success:
try:
TheSession = request.GET.get("session")
TheActivity = int(request.GET.get("activityId"))
try:
TheCode = request.GET.get("code")
except:
TheCode = None
try:
TheDistance = int(request.GET.get("distance"))
except:
TheDistance = None
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:
JudgeResult = JudgeValid.JudgeUserValid(TheUserID)
if JudgeResult != True:
Success = False
Reason = "用户已被封禁，不能操作！！"
ErrorID = Constants.ERROR_CODE_INVALID_CHANGE
#调用数据库函数添加活动
if Success:
try:
Info = UserActivityManager.CheckInActivity(TheUserID, TheActivity,
TheCode, TheDistance)
#print(Info)
if Info["result"] != "success":
Success = False
Reason = Info["reason"]
ErrorID = Info["code"]
except:
Success = False
Reason = "签到失败"
ErrorID = Constants.ERROR_CODE_UNKNOWN
if Success:
Return["result"] = "success"
else:
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
def SetExtraData(request):
'''
描述：处理设置用户补充信息请求
参数：request
成功返回：
{
“result”：“success”
}
失败返回：
{"errid": 101, "errmsg": "身份信息不存在"}
'''
Success = True
Return = {}
Info = {}
RequestBody = {}
ErrorId = Constants.UNDEFINED_NUMBER
Reason = ""
TheSession = ""
SelfOpenID = ""
TheURL = ""
#获取请求数据
if Success:
try:
TheSession = request.GET.get("session")
except:
Success = False
Reason = "请求参数不合法！"
ErrorId = Constants.ERROR_CODE_INVALID_PARAMETER
#判断是否登录，获取待查询的openid
if Success:
try:
SelfOpenID = UserManager.GetCurrentUser(TheSession)
if SelfOpenID == None:
Success = False
Reason = "用户未登录！"
ErrorId = Constants.ERROR_CODE_LOGIN_ERROR
except:
Success = False
Reason = "用户未登录！"
ErrorId = Constants.ERROR_CODE_LOGIN_ERROR
#判断是否被封禁
if Success:
JudgeResult = JudgeValid.JudgeUserValid(SelfOpenID)
if JudgeResult != True:
Success = False
Reason = "用户已被封禁，不能操作！！"
ErrorId = Constants.ERROR_CODE_INVALID_CHANGE
#调用数据库函数进行操作
if Success:
try:
RequestBody = json.loads(request.body)
except:
Success = False
Reason = "请求参数不合法！"
ErrorId = Constants.ERROR_CODE_INVALID_PARAMETER
if Success:
try:
QueryResult = UserManager.SetUserExtraData(SelfOpenID, RequestBody)
if QueryResult["result"] != "success":
Success = False
Reason = QueryResult["reason"]
ErrorId = QueryResult["code"]
except:
Success = False
Reason = "设置头像url失败！"
ErrorId = Constants.ERROR_CODE_UNKNOWN
if Success:
Return["result"] = "success"
else:
Return["errid"] = ErrorId
Return["errmsg"] = Reason
Response = JsonResponse(Return)
if Success == True:
Response.status_code = 200
else:
Response.status_code = 400
return Response
def StartActivity(request):
'''
描述：处理添加活动请求
参数：request
成功返回：
{
“id”:”0000001”(活动id)
}
失败返回：
{"errid": 101, "errmsg": "身份信息不存在"}
'''
Success = True
Return = {}
Info = {}
RequestBody = {}
ErrorId = Constants.UNDEFINED_NUMBER
Reason = ""
TheSession = ""
SelfOpenID = ""
#print(request.POST)
#获取请求数据
if Success:
try:
TheSession = request.GET.get("session")
except:
Success = False
Reason = "请求参数不合法！"
ErrorId = Constants.ERROR_CODE_INVALID_PARAMETER
#判断是否登录， 获取待查询的openid
if Success:
try:
SelfOpenID = UserManager.GetCurrentUser(TheSession)
if SelfOpenID == None:
Success = False
Reason = "用户未登录！"
ErrorId = Constants.ERROR_CODE_LOGIN_ERROR
except:
Success = False
Reason = "用户未登录！"
ErrorId = Constants.ERROR_CODE_LOGIN_ERROR
#判断是否被封禁
if Success:
JudgeResult = JudgeValid.JudgeUserValid(SelfOpenID)
if JudgeResult != True:
Success = False
Reason = "用户已被封禁，不能操作！！"
ErrorId = Constants.ERROR_CODE_INVALID_CHANGE
#调用数据库函数进行操作
if Success:
try:
RequestBody = json.loads(request.body)
Info = ActivityManager.AddActivity(SelfOpenID, RequestBody)
except:
Success = False
Reason = "请求参数不合法！"
ErrorId = Constants.ERROR_CODE_INVALID_PARAMETER
if Success:
if Info["result"] == "success" or Info["result"] == "needAudit":
Return["activityId"] = str(Info["activityId"])
Return["result"] = Info["result"]
else:
if ErrorId == Constants.UNDEFINED_NUMBER:
Success = False
Return["errmsg"] = Info["reason"]
Return["errid"] = Info["code"]
else:
Return["errid"] = ErrorId
Return["errmsg"] = Reason
Response = JsonResponse(Return)
if Success:
Response.status_code = 200
else:
Response.status_code = 400
return Response
def QuitActivity(TheUserID, TheActivityID):
'''
描述：退出报名函数
参数：用户id，活动id,是否是管理员,报名原因（没有就是None）
返回：成功{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
if Success:
if JudgeValid.JudgeActivityNormal(TheActivityID) != True:
Success = False
Reason = "活动状态为异常或结束，不能操作！"
Code = Constants.ERROR_CODE_INVALID_CHANGE
if Success:
try:
Info = JoinInformation.objects.get(UserId = TheUser, ActivityId = TheActivity)
#print(Info)
except:
Success = False
Reason = "用户未加入活动！"
Code = Constants.ERROR_CODE_NOT_FOUND
if Success:
try:
TheStatus = Info.Status
TheRole = Info.Role
if TheRole == Constants.USER_ROLE_CREATOR:
Success = False
Reason = "创建者不能退出活动！"
Code = Constants.ERROR_CODE_INVALID_CHANGE
if JudgeValid.JudgeUserStatusCanQuit(TheStatus) != True:
Success = False
Reason = "只有待审核用户和正式参与者可以退出活动！"
Code = Constants.ERROR_CODE_INVALID_CHANGE
except:
Success = False
Reason = "退出活动失败"
Code = Constants.ERROR_CODE_UNKNOWN
if Success:
try:
Info.delete()
if TheStatus != Constants.USER_STATUS_WAITVALIDATE:
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
