def _get(self, _app_uuid, _group_uuid):
        _redis = self.application.redis
        _key = OrgGroup.__tablename__ + ".app_uuid." + _app_uuid
        _is = _redis.sismember(_key, _group_uuid)
        if _is != True:
            self.setErrorCode(API_ERR.NO_ORG_GROUP)
            return

        _row = OrgGroup(uuid=_group_uuid)
        _row.async_delete(_redis)
        _row.delete_redis_keys(_redis)
        return
def update_group_icon(_redis, _group_uuid):
    _key = OrgUserGroupData.__tablename__ + ".group_uuid." + _group_uuid
    _users = _redis.smembers(_key)
    _group_icon = None
    if len(_users) == 0:
        _group_icon = create_user_icon(_group_uuid)
    else:
        _group_icon = create_group_icon(_redis, _users)
    _row = OrgGroup(uuid=_group_uuid, group_icon=_group_icon)
    _row.update_redis_keys(_redis)
    _row.async_update()
    return
    def _remove(self, _app_uuid, _group_uuid):
        _redis = self.application.redis
        _key = OrgGroup.__tablename__ + ".app_uuid." + _app_uuid
        _is = _redis.sismember(_key, _group_uuid)
        
        if _is != True:
            logging.error("group: %s not belong to app_uuid: %s" % (_group_uuid, _app_uuid))
            return

        _row = OrgGroup(uuid=_group_uuid)
        _row.async_delete(_redis)
        _row.delete_redis_keys(_redis)
        return
 def _get(self, _app_uuid, _group_name, _group_desc):
     _redis = self.application.redis
     _uuid = str(uuid.uuid1())
     _row = OrgGroup(
         uuid=_uuid,
         app_uuid=_app_uuid,
         group_name=_group_name,
         group_icon=create_user_icon(_uuid), 
         group_desc=_group_desc
     )
     _row.async_add()
     _row.create_redis_keys(_redis)
             
     _group = redis_hash_to_dict(_redis, OrgGroup, _row.uuid)
     if _group == None:
         self.setErrorCode(API_ERR.NO_ORG_GROUP)
         return
     _r = self.getReturnData()
     _r.update(_group)
     return
Exemple #5
0
    def _get(self, _app_uuid, _group_uuid, _body):
        _redis = self.application.redis
        _key = OrgGroup.__tablename__ + \
                   ".app_uuid." + _app_uuid
        _is = _redis.sismember(_key, _group_uuid)
        if _is != True:
            self.setErrorCode(API_ERR.NO_ORG_GROUP)
            return

        _group = redis_hash_to_dict(_redis, OrgGroup, _group_uuid)
        if _group == None:
            self.setErrorCode(API_ERR.NO_ORG_GROUP)
            return
        del _body["group_uuid"]
        del _body["app_uuid"]
        
        for _i in _body:
            if _i not in _group:
                logging.error("can not set: %s" % _i)
                continue
            _group[_i] = _body[_i]
            
        _r = self.getReturnData()
        for _i in _group:
            _r[_i] = _group[_i]
        _r["group_uuid"] = _group["uuid"]

        del _group["createtime"]
        del _group["updatetime"]

        _row = OrgGroup(**_group)
        _row.async_update()
        _row.update_redis_keys(_redis)
        return
def update_group_icon(_redis, _group_uuid):
    _key = OrgUserGroupData.__tablename__ + ".group_uuid." + _group_uuid
    _users = _redis.smembers(_key)
    _group_icon = None
    if len(_users) == 0:
        _group_icon = create_user_icon(_group_uuid)
    else:
        _group_icon = create_group_icon(_redis, _users)
    _row = OrgGroup(uuid=_group_uuid, group_icon=_group_icon)
    _row.update_redis_keys(_redis)
    _row.async_update()
    return
    def _get(self, _app_uuid, _group_uuid):
        _redis = self.application.redis
        _key = OrgGroup.__tablename__ + \
               ".app_uuid." + _app_uuid
        _is = _redis.sismember(_key, _group_uuid)
        if _is != True:
            self.setErrorCode(API_ERR.NO_ORG_GROUP)
            return

        _row = OrgGroup(uuid=_group_uuid)
        _row.async_delete(_redis)
        _row.delete_redis_keys(_redis)
        return
    def _remove(self, _app_uuid, _group_uuid):
        _redis = self.application.redis
        _key = OrgGroup.__tablename__ + ".app_uuid." + _app_uuid
        _is = _redis.sismember(_key, _group_uuid)

        if _is != True:
            logging.error("group: %s not belong to app_uuid: %s" %
                          (_group_uuid, _app_uuid))
            return

        _row = OrgGroup(uuid=_group_uuid)
        _row.async_delete(_redis)
        _row.delete_redis_keys(_redis)
        return
    def _get(self, _app_uuid, _group_name, _group_desc):
        _redis = self.application.redis
        _uuid = str(uuid.uuid1())
        _row = OrgGroup(uuid=_uuid,
                        app_uuid=_app_uuid,
                        group_name=_group_name,
                        group_icon=create_user_icon(_uuid),
                        group_desc=_group_desc)
        _row.async_add()
        _row.create_redis_keys(_redis)

        _group = redis_hash_to_dict(_redis, OrgGroup, _row.uuid)
        if _group == None:
            self.setErrorCode(API_ERR.NO_ORG_GROUP)
            return
        _r = self.getReturnData()
        _r.update(_group)
        return
def Csv2Mysql(csv_file):
    dbsession_class = getDatabaseInstance().dbsession_class
    db_session = dbsession_class()
    csv_data = csv.reader(file(csv_file))

    flag = 0
    for i in csv_data:
        flag += 1
        if flag != 1:
            row = []
            for item in i:
                row.append(encodeToUtf8(item, code_str))
            try:
                user_id = isUserExists(db_session, row[0])
                if not user_id:
                    deviceuser = DeviceUser()
                    deviceuser.user_name = row[0]
                    deviceuser.user_fullname = row[1]
                    deviceuser.user_email = row[2]
                    deviceuser.user_type = row[3]
                    deviceuser.user_status = row[4]
                    deviceuser.user_icon = "/static/yvertical/assets/img/user1.png"
                    deviceuser.user_gender = row[5]
                    deviceuser.user_dob = row[6]
                    deviceuser.user_doj = row[7]
                    deviceuser.user_rid = row[8]
                    deviceuser.user_iid = row[9]
                    is_byod = isByod(row[12])
                    deviceuser.user_is_byod = is_byod
                    deviceuser.user_is_enod = not is_byod
                    db_session.add(deviceuser)
                    db_session.commit()
                    user_id = deviceuser.id
            except:
                dbsession_class.remove()
                traceback.print_exc()
                break
                
            try:
                group_id = isGroupExists(db_session, row[11])
                if not group_id:
                    orggroup = OrgGroup()
                    orggroup.group_name = row[11]
                    orggroup.group_icon = "/static/yvertical/assets/img/group.jpg"
                    db_session.add(orggroup)
                    db_session.commit()
                    group_id = orggroup.id
            except:
                dbsession_class.remove()
                traceback.print_exc()

            try:
                user_data_id = isUserDataExists(db_session, user_id, group_id)
                if not user_data_id:
                    user_data = OrgGroupUserData()
                    user_data.group_id = group_id
                    user_data.user_id = user_id
                    user_data.is_leader = isLeader(row[10])
                    db_session.add(user_data)
                    db_session.commit()
            except:
                dbsession_class.remove()
                traceback.print_exc()

        else:
            if isinstance(i[0], unicode):
                code_str = None
            else:
                code_str = chardet.detect(i[0])["encoding"]