// add home normal member
func (this *MemberManager) AddMember(domain string, hid, uid int64, member string) error {
	common.CheckParam(this.store != nil)
	if len(member) <= 0 {
		log.Warningf("check member name failed:domain[%s], member[%s], uid[%d], hid[%d]",
			domain, member, uid, hid)
		return common.ErrInvalidName
	}
	// step 1. get home info
	homeManager := NewHomeManager(this.store)
	home, err := homeManager.Get(domain, hid)
	if err != nil {
		log.Warningf("get home failed:domain[%s], hid[%d], err[%v]", domain, hid, err)
		return err
	} else if home == nil {
		log.Warningf("home not exist:domain[%s], hid[%d]", domain, hid)
		return common.ErrEntryNotExist
	} else if home.GetStatus() != ACTIVE {
		log.Warningf("check home status failed:domain[%s], hid[%d]", domain, hid)
		return common.ErrInvalidStatus
	} else if home.GetCreateUid() == uid {
		// do not return error
		log.Warningf("the user is creator:domain[%s], hid[%d], uid[%d]", domain, hid, home.createUid)
		return nil
	}
	// step 2. add member, if exist return error
	err = this.insertMemberInfo(domain, member, hid, uid)
	if err != nil {
		log.Warningf("insert one member to home faileddomain[%s], hid[%d], uid[%d]", domain, hid, uid)
		return err
	}
	return nil
}
// modify member info all column can be modified
func (this *MemberManager) modifyMemberInfo(domain string, hid, uid int64, key string, value interface{}) error {
	common.CheckParam(len(key) != 0)
	SQL := fmt.Sprintf("UPDATE %s_home_members SET %s = ? WHERE uid = ? AND hid = ?", domain, key)
	stmt, err := this.store.db.Prepare(SQL)
	if err != nil {
		log.Errorf("prepare query failed:err[%v]", err)
		return err
	}
	defer stmt.Close()
	result, err := stmt.Exec(value, uid, hid)
	if err != nil {
		log.Errorf("execute update failed:sql[%s], err[%v]", SQL, err)
		return err
	}
	affect, err := result.RowsAffected()
	if err != nil {
		log.Warningf("get affected rows failed:err[%v]", err)
		return err
	}
	if affect < 1 {
		log.Warningf("check affected rows failed:domain[%s], hid[%d], uid[%d], row[%d]", domain, hid, uid, affect)
		return common.ErrEntryNotExist
	} else if affect > 1 {
		log.Errorf("check affected rows failed:domain[%s], hid[%d], uid[%d], row[%d]", domain, hid, uid, affect)
		return common.ErrUnknown
	}
	return nil
}
// modify device info all column can be modified
func (this *DeviceManager) modifyDeviceInfo(checkStatus bool, domain string, did int64, key string, value interface{}) error {
	common.CheckParam(len(key) != 0)
	var SQL string
	if checkStatus {
		SQL = fmt.Sprintf("UPDATE %s_device_info SET %s = ? WHERE did = ? AND status = %d", domain, key, ACTIVE)
	} else {
		SQL = fmt.Sprintf("UPDATE %s_device_info SET %s = ? WHERE did = ?", domain, key)
	}
	stmt, err := this.store.db.Prepare(SQL)
	if err != nil {
		log.Errorf("prepare query failed:err[%v]", err)
		return err
	}
	defer stmt.Close()
	result, err := stmt.Exec(value, did)
	if err != nil {
		log.Errorf("execute update failed:domain[%s], key[%s], value[%v], err[%v]", domain, key, value, err)
		return err
	}
	affect, err := result.RowsAffected()
	if err != nil {
		log.Warningf("get affected rows failed:err[%v]", err)
		return err
	}
	if affect != 1 {
		log.Warningf("update device info failed:domain[%s], key[%s], value[%v], err[%v]", domain, key, value, err)
		return common.ErrEntryNotExist
	}
	return nil
}
// add home owner
func (this *MemberManager) AddOwner(domain, owner string, hid, uid int64) error {
	common.CheckParam(this.store != nil)
	if len(owner) <= 0 {
		log.Warningf("check owner name failed:domain[%s], owner[%s], uid[%d], hid[%d]",
			domain, owner, uid, hid)
		return common.ErrInvalidName
	}
	return this.addOwnerMember(domain, owner, hid, uid)
}
// get all homeids belong to this member, if no hid return empty list
func (this *MemberManager) GetAllHomeIds(domain string, uid int64) ([]int64, error) {
	common.CheckParam(this.store != nil)
	list, err := this.getMemberAllHomes(domain, uid)
	if err != nil {
		log.Warningf("get member all home ids failed:domain[%s], uid[%d], err[%v]",
			domain, uid, err)
		return nil, err
	}
	return list, nil
}
// get all members of the home, if (hid) not exist,
// return empty list, not nil + nil
func (this *MemberManager) GetAllMembers(domain string, hid int64) ([]Member, error) {
	common.CheckParam(this.store != nil)
	// if home not exist, return empty list
	list, err := this.getAllMembers(domain, hid)
	if err != nil {
		log.Warningf("get one home all members failed:domain[%s], hid[%d], err[%v]", domain, hid, err)
		return nil, err
	}
	return list, nil
}
// delete the home and delete all the members
func (this *MemberManager) DeleteAllMembers(domain string, hid int64) error {
	common.CheckParam(this.store != nil)
	err := this.deleteAllMembers(domain, hid)
	if err != nil {
		log.Warningf("delete home all members failed:domain[%s], hid[%d], err[%s]",
			domain, hid, err)
		return err
	}
	return nil
}
Exemple #8
0
////////////////////////////////////////////////////////////////////////////////////
// public interface
/////////////////////////////////////////////////////////////////////////////////////
// if find the record return home + nil, else if no record return nil + nil
func (this *HomeManager) Get(domain string, hid int64) (*Home, error) {
	common.CheckParam(this.store != nil)
	var home Home
	err := this.getHome(domain, hid, &home)
	if err != nil {
		if err == common.ErrEntryNotExist {
			return nil, nil
		} else {
			log.Warningf("get home failed:domain[%s], hid[%d]", domain, hid)
			return nil, err
		}
	}
	return &home, nil
}
////////////////////////////////////////////////////////////////////////////////////
// public interface
////////////////////////////////////////////////////////////////////////////////////
// get member for check if the user has privelige, if not exist return nil + nil
func (this *MemberManager) Get(domain string, hid, uid int64) (*Member, error) {
	common.CheckParam(this.store != nil)
	var member Member
	err := this.getMemberInfo(domain, hid, uid, &member)
	if err != nil {
		if err == common.ErrEntryNotExist {
			return nil, nil
		} else {
			log.Warningf("get member info failed:domain[%d], hid[%d], uid[%d]", domain, hid, uid)
			return nil, err
		}
	}
	return &member, nil
}
// change the slave or master device, the old must valid
func (this *BindingManager) ChangeBinding(did int64, domain, subDomain, deviceId string) error {
	common.CheckParam(this.proxy != nil && this.warehouse != nil)
	// step 1. check the old did must be register succ
	var device DeviceInfo
	deviceManager := NewDeviceManager(this.store)
	err := deviceManager.getDeviceInfo(domain, did, &device)
	if err != nil {
		log.Warningf("get master device failed:domain[%s], did[%d], err[%v]", domain, did, err)
		return err
	}
	// step 2 check the old did must be binging ok
	var exist bool
	err = this.proxy.IsBindingExist(domain, did, &exist)
	if err != nil {
		log.Warningf("check binding exist failed:domain[%s], did[%d], err[%v]", domain, did, err)
		return err
	} else if !exist {
		log.Warningf("the old did not binding:domain[%s], did[%d]", domain, did)
		return common.ErrNotYetBinded
	}
	// step 3. check the new device basic info is valid according the old device type
	err = this.checkDeviceInfo(domain, subDomain, deviceId, device.IsMasterDevice())
	if err != nil {
		log.Warningf("check device info failed:domain[%s], device[%s:%s], master[%d], err[%v]",
			domain, subDomain, deviceId, did, err)
		return err
	}
	// step 4. check the new device is not binding by others
	_, err = this.proxy.GetBindingInfo(domain, subDomain, deviceId)
	if err != nil {
		if err != common.ErrEntryNotExist {
			log.Warningf("get device binding info failed:domain[%s], device[%s:%s], master[%d], err[%v]",
				domain, subDomain, deviceId, did, err)
			return err
		}
	} else {
		log.Warningf("check the device is already binded:domain[%s], device[%s:%s], did[%d]",
			domain, subDomain, deviceId, did)
		return common.ErrAlreadyBinded
	}
	// step 5. change the mapping relation
	err = this.proxy.ChangeDeviceBinding(did, domain, subDomain, deviceId)
	if err != nil {
		log.Warningf("do change the device mapping binding info failed:domain[%s], device[%s:%s], err[%v]",
			domain, subDomain, deviceId, err)
		return err
	}
	return nil
}
Exemple #11
0
func (this *HomeManager) ModifyName(domain string, hid int64, name string) error {
	common.CheckParam(this.store != nil)
	home, err := this.Get(domain, hid)
	if err != nil {
		log.Warningf("get home failed:domain[%s], hid[%d], err[%v]", domain, home, err)
		return err
	} else if home == nil {
		log.Warningf("home not exist:domain[%s], hid[%d]", domain, hid)
		return common.ErrEntryNotExist
	} else if home.GetStatus() != ACTIVE {
		log.Warningf("home is not active:domain[%s], hid[%d]", domain, hid)
		return common.ErrInvalidStatus
	}
	return this.modifyHome(domain, hid, "name", name)
}
Exemple #12
0
// create a new home
func (this *HomeManager) Create(domain string, uid int64, name string) error {
	common.CheckParam(this.store != nil)
	if len(name) <= 0 {
		log.Warningf("check the home name failed:uid[%d], name[%s]", uid, name)
		return common.ErrInvalidParam
	}
	hid, err := this.insertHome(domain, uid, name)
	if err != nil {
		log.Warningf("insert home failed:domain[%s], createUid[%d], name[%s]", domain, uid, name)
		return err
	}
	// insert member as creator type to the home_members
	member := NewMemberManager(this.store)
	err = member.AddOwner(domain, "owner", hid, uid)
	if err != nil {
		log.Errorf("add owner to the home failed:domain[%s], createUid[%d], name[%s]", domain, uid, name)
		return err
	}
	return nil
}
Exemple #13
0
// if no home, return empty list not nil
func (this *HomeManager) GetAllHome(domain string, uid int64) ([]Home, error) {
	common.CheckParam(this.store != nil)
	member := NewMemberManager(this.store)
	homeIds, err := member.GetAllHomeIds(domain, uid)
	if err != nil {
		log.Warningf("get all home id list failed:domain[%s], uid[%d], err[%v]", domain, uid, err)
		return nil, err
	}
	list := make([]Home, 0)
	for _, hid := range homeIds {
		home, err := this.Get(domain, hid)
		if err != nil {
			log.Warningf("get home info failed:domain[%s], uid[%d], hid[%d]", domain, uid, hid)
			return nil, err
		} else if home == nil {
			log.Warningf("check home not exist:domain[%s], uid[%d], hid[%d]", domain, uid, hid)
		} else {
			list = append(list, *home)
		}
	}
	return list, nil
}
// del a member from a home
func (this *MemberManager) Delete(domain string, hid, uid int64) error {
	common.CheckParam(this.store != nil)
	homeManager := NewHomeManager(this.store)
	// step 1. check home info
	home, err := homeManager.Get(domain, hid)
	if err != nil {
		log.Warningf("get home failed:domain[%s], hid[%d], err[%v]", domain, hid, err)
		return err
	} else if home == nil {
		log.Warningf("home not exist:domain[%s], hid[%d]", domain, hid)
		return common.ErrEntryNotExist
	} else if home.GetStatus() != ACTIVE {
		log.Warningf("check home status failed:domain[%s], hid[%d]", domain, hid)
		return common.ErrInvalidStatus
	}
	// step 2. delete member, if not exist return succ
	err = this.deleteOneMember(domain, hid, uid)
	if err != nil {
		log.Warningf("delete one member of home failed:domain[%s], hid[%d], err[%s]", domain, hid, err)
		return err
	}
	return nil
}
// binding one device to one home, if masterDid < 0 it's master device, otherwise it's slave device
func (this *BindingManager) Binding(domain, subDomain, deviceId, deviceName string, hid, masterDid int64) error {
	common.CheckParam(this.proxy != nil && this.warehouse != nil)
	// step 1. check the device basic info is valid
	err := this.checkDeviceInfo(domain, subDomain, deviceId, masterDid < 0)
	if err != nil {
		log.Warningf("check the binding device failed:err[%v]", err)
		return err
	}
	// step 2. check the master device is binding ok
	if masterDid > 0 {
		_, err = this.proxy.GetBindingByDid(domain, masterDid)
		if err != nil {
			log.Warningf("check the master device not active:domain[%s], did[%d], err[%v]", domain, masterDid, err)
			return err
		}
	}
	// step 3. build mapping device ids, if already exist return succ for rebinding...
	err = this.proxy.BindingDevice(domain, subDomain, deviceId, deviceName, hid, masterDid)
	if err != nil {
		log.Warningf("binding device failed:domain[%s], device[%s:%s], master[%d]", domain, subDomain, deviceId, masterDid)
		return err
	}
	return nil
}
Exemple #16
0
// TODO do not really delete the home info from the storage
func (this *HomeManager) Delete(domain string, hid int64) error {
	common.CheckParam(this.store != nil)
	// step 1.delete all the devices not in a transaction
	device := NewDeviceManager(this.store)
	err := device.DeleteAllDevices(domain, hid)
	if err != nil {
		log.Warningf("delete the home devices failed:domain[%s], hid[%d], err[%v]", domain, hid, err)
		return err
	}
	// step 2. delete all the members not in a transaction
	member := NewMemberManager(this.store)
	err = member.DeleteAllMembers(domain, hid)
	if err != nil {
		log.Errorf("delete the home all members failed:domain[%s], hid[%d], err[%v]", domain, hid, err)
		return err
	}
	// step 3. delete the home info from
	err = this.deleteHome(domain, hid)
	if err != nil {
		log.Warningf("delete home info failed:domain[%s], hid[%d], err[%v]", domain, hid, err)
		return err
	}
	return nil
}
Exemple #17
0
func (this *HomeManager) Enable(domain string, hid int64) error {
	common.CheckParam(this.store != nil)
	return this.modifyHome(domain, hid, "status", ACTIVE)
}
// if not exist return nil + nil
func (this *BindingManager) GetBindingInfo(domain, subDomain, deviceId string) (*BindingInfo, error) {
	common.CheckParam(this.proxy != nil && this.warehouse != nil)
	return this.proxy.GetBindingInfo(domain, subDomain, deviceId)
}