import {request, config} from 'utils'
const {api} = config;

export async function loginCb(data) {
  return request({
    url: api.userLoginCB,
    method: 'get',
    data,
  })
}

yield put({
  type: 'querySuccess',
  payload: {
    data: data,
  },
})

* query({
          url,
          payload,
        }, {call, put}) {
  const {data} = yield call(url, payload);
  yield put({
    type: 'querySuccess',
    payload: {
      data: data,
    },
  })
},

export default connect(({ detail, loading }) => ({ state:detail, loading }))(Detail)

const handleOk = () => {
  validateFields((errors) => {
    if (errors) {
      return
    }
    const data = {
      ...item,
      ...getFieldsValue(),
    };
    onOk(data)
  })
};

// 多重
const handleChange = (count) => (fileList) => {
	// do sth
};

const data = {
  ...item,
  ...getFieldsValue(),
};

import React from 'react'
import { config } from 'utils'
import styles from './Footer.less'

const Footer = () => (<div className={styles.footer}>
  {config.footerText}
</div>)

export default Footer

dispatch(routerRedux.push({
  pathname: buildUrl(route.apartmentBatchPrice,{id:record.id}),
}))

const queryString = require('query-string');
location.query = queryString.parse(location.search);

import modelExtend from 'dva-model-extend'

const model = {
  reducers: {
    updateState (state, { payload }) {
      return {
        ...state,
        ...payload,
      }
    },
  },
};

const pageModel = modelExtend(model, {
  state: {
    list: [],
    pagination: {
      showSizeChanger: false,
      showQuickJumper: false,
      showTotal: total => `共 ${total} 条记录`,
      current: 1,
      total: 0,
    },
  },

  reducers: {
    querySuccess (state, { payload }) {
      const { list, pagination } = payload
      return {
        ...state,
        ...{list:list},
        pagination: {
          ...state.pagination,
          ...pagination,
        },
      }
    },
  },

});


module.exports = {
  model,
  pageModel,
};

const pageModel = modelExtend(model, model2 {
	// ...
}

import {request, config} from 'utils'
import {buildUrl} from '../utils/url'

export function createService(keys) {
  let res = {};
  let exclude = {}
  if (keys["create"]) {
    res["create"] =
      async function create(data, param=null) {
        return request({
          url: buildUrl(keys.create, param),
          method: 'post',
          data,
        })
      }
    exclude["create"] = null
  }

  if (keys["query"]) {
    res["query"] =
      async function query(data, param=null) {
        return request({
          url: buildUrl(keys.query, param),
          method: 'get',
          data,
        })
      }
    exclude["query"] = null
  }

  if (keys["detail"]) {
    res["detail"] =
      async function detail(param = null) {
        return request({
          url: buildUrl(keys.detail, param),
          method: 'get',
        })
      }
    exclude["detail"] = null
  }

  if (keys["update"]) {
    res["update"] =
      async function update(data, param=null) {
        return request({
          url: buildUrl(keys.update, param),
          method: 'put',
          data: data,
        })
      }
    exclude["update"] = null
  }

  if (keys["enable"]) {
    res["enable"] =
      async function enable(param = null) {
        return request({
          url: buildUrl(keys.enable, param),
          method: 'post',
        })
      }
    exclude["enable"] = null
  }

  if (keys["disable"]) {
    res["disable"] =
      async function disable(param = null) {
        return request({
          url: buildUrl(keys.disable, param),
          method: 'post',
        })
      }
    exclude["disable"] = null
  }

  if (keys["remove"]) {
    res["remove"] =
      async function remove(param = null) {
        return request({
          url: buildUrl(keys.remove, param),
          method: 'delete',
        })
      }
    exclude["remove"] = null
  }

  const methods = {
    "post": null,
    "put": null,
    "get": null,
    "delete": null,
    "patch": null,
  }

  for (const key in keys) {
    if (keys.hasOwnProperty(key)){
      // 排除上面的通用方法
      if(key in exclude) continue
      // 必须是对象
      if(typeof keys[key] === 'object'){
        const rt = keys[key]
        // 合法的方法
        if(!rt.method in methods) {
          continue
        }

        res[key] =
          async function create(data, param=null) {
            return request({
              url: buildUrl(rt.url, param),
              method: rt.method,
              data,
            })
          }
      }
    }
  }

  return res
}

import {request, config} from 'utils'
import {createService} from "./common"

exports.services = createService(config.api.user);

user: {
  "query": `${APIV1}/users/`,
  "update": `${APIV1}/users/:id`,
  "detail": `${APIV1}/users/:id`,
  "enable": `${APIV1}/users/:id/enable`,
  "disable": `${APIV1}/users/:id/disable`
},

import {request, config} from 'utils'
import {createService} from "./common"

let routes = config.api.price
if(typeof routes["generate"] != 'object'){
  routes['generate'] = {
    "method": "post",
    "url": routes['generate']
  }
}

exports.services = createService(routes);

price: {
  "create": `${APIV1}/:id/prices`,
  "update": `${APIV1}/:id/prices`,
  "query": `${APIV1}/:id/prices`,
  "generate": `${APIV1}/:id/prices/generate`,
}

setup({dispatch, history}) {
  history.listen((location) => {

    const match = pathToRegexp(route.apartments).exec(location.pathname);
    if (match) {
      location.query = queryString.parse(location.search);
      const payload = location.query || {page: 1, count: countPePage};
      dispatch({
        type: 'query',
        payload,
      })
    }
  })
},

import pathToRegexp from 'path-to-regexp'

module.exports = {
  buildUrl:(url, param) => {
    if(!param) return url;

    const toPath = pathToRegexp.compile(url);
    return toPath(param);
  },

  parseUrl:(url,route) => {
    const match = pathToRegexp(route).exec(url)
    if(!match) return {}

    let urlDatas = {};
    let index = 1;
    const keys = pathToRegexp.parse(route)
    keys.forEach(function(item){
      if(typeof item !== 'object'){
        return
      }
      urlDatas[item.name] = match[index]
      index ++
    });
    return urlDatas
  }
};

yield put(routerRedux.push({
  pathname: buildUrl(route.storeDetailIndex,{id:store.id,tab:route.storeDetailTab.rule}),
}))

const urlDatas = parseUrl(location.pathname, current.route);
pathArray.forEach(function (item) {
  if(item === current || !item.route) return;
  item.route2 = buildUrl(item.route,urlDatas)
})

import createLoading from 'dva-loading'
// 1. Initialize
const app = dva({
  ...createLoading({
    effects: true,
  }),
});

export default connect(({ detail, loading }) => ({ state:detail, loading }))(Detail)

<Button type="primary" size="large" loading={loading.effects.login}>
  登录
</Button>

const LoginCB = ({location, dispatch, loading}) => {
  return (
    <div>
      <Loader fullScreen spinning={loading.effects['login_cb/login']} />
    </div>
  )
}

<Form.Item {...props}>
  {children}
</Form.Item>

import React from 'react'
import {Select} from 'antd';
import {connect} from 'dva'
import {Icon} from 'antd';
import PropTypes from 'prop-types';
const {Option} = Select;

class IDSelect extends React.Component {
  constructor(props) {
    super(props);

    const value = this.props.value || [];
    this.state = {
      current_value: undefined,
      list: [],
    };
  }

  componentWillReceiveProps(nextProps) {
    // Should be a controlled component.
    if ('value' in nextProps) {
      // ----- mark------
      const value = nextProps.value;
      if(value === undefined) return

      if (!value){
        this.setState({current_value: null});
      }else{
        this.setState({current_value:String(value)});
      }
    }

    if ('list' in nextProps) {
      const list = nextProps.list;
      if(list === undefined) return
      this.setState({list});
    }
  }

  render() {
    const handleChange = (value) => {
      this.setState({current_value:value});
      // ----- mark------
      const onChange = this.props.onChange;
      if (onChange) {
        onChange(parseInt(value));
      }
    }

    const {list,value,...props} = this.props
    return (
      <span>
      {this.state.list.length > 0 && <Select
        {...props}
        defaultValue={this.state.current_value}
        onChange={handleChange}
        >
          {this.state.list.map(function (object, i) {
            return <Option value={String(object.id)} key={i}>{object.name}</Option>;
          })}
        </Select>}
      </span>
    );
  }
}

IDSelect.propTypes = {
  value: PropTypes.number,
  list: PropTypes.arrayOf(PropTypes.object),
};

module.exports = {
  IDSelect,
};

<FormItem>
  {getFieldDecorator('user_id', {
    initialValue: state.editType === 'create' ? null : data.user_id,
    rules: [
      {
        required: true,
      }
    ],
  })(
    <IDSelect
      disabled={state.editType !== 'create'}
      list={state.users}
    />
  )}
</FormItem>

const handleSubmit = (e) => {
  e.preventDefault();
  form.validateFields((err, values) => {
    if (!err) {
        // do submit
    }
  });
};

const checkCoordinate = (rule, value, callback) => {
  if(!parseCoordinate(value)){
    callback("错误的经纬度");
    return
  }

  callback();
};

<FormItem>
  {getFieldDecorator('coordinate', {
    initialValue: state.editType === 'create' ? "" : String(data.lng) + ',' + String(data.lat),
    rules: [
      {
        required: true,
        min: 1,
        max: 64,
      },
      {validator: checkCoordinate},
    ],
  })(<Input placeholder="请输入经纬度" style={{width: '100%'}}/>)}
</FormItem>

module.exports = {
  parseCoordinate:(value) => {
    const values = value.split(",");
    if (values.length !== 2) {
      return null;
    }

    try {
      return {
        lng: parseFloat(values[0]),
        lat: parseFloat(values[1])
      };
    }
    catch (e) {
      return null;
    }
  }
}

<FormItem
  label="位置"
  required
  {...formItemLayout}
>
  <Col span={6}>
    <FormItem>
      {getFieldDecorator('param1', {
        initialValue: state.editType === 'create' ? "" : data.param1,
        rules: [
          {
            required: true,
            min: 1,
            max: 32
          },
        ],
      })(<Input style={{width: '100%'}}/>)}
    </FormItem>
  </Col>
  <Col span={6}>
    <FormItem>
      {getFieldDecorator('param2', {
        initialValue: state.editType === 'create' ? "" : data.param2,
        rules: [
          {
            required: true,
            type: "integer"
          },
        ],
      })(<InputNumber style={{width: '100%'}}/>)}
    </FormItem>
  </Col>
</FormItem>

// 一行多表单
<FormItem
  label="位置"
  required
  {...formItemLayout}
>

import {Editor} from 'react-draft-wysiwyg';
import 'react-draft-wysiwyg/dist/react-draft-wysiwyg.css';
import { EditorState, convertToRaw, ContentState, convertFromHTML } from 'draft-js';

const checkContent = (rule, value, callback) => {
  if (value && state.editorState) {
    const content = draftToHtml(convertToRaw(state.editorState.getCurrentContent()));
    if(content.length < 9 || content.length >= 1024000){
      callback("content must be between 2 and 1024000 characters\n");
      return
    }
  }
  callback();
};

const uploadImageCallBack = (file) => {
  return new Promise(
    (resolve, reject) => {
      const xhr = new XMLHttpRequest();
      xhr.open('POST', '/api/v1/upload');
      const data = new FormData();
      data.append('file', file);
      xhr.send(data);
      xhr.addEventListener('load', () => {
        let response = JSON.parse(xhr.responseText);
        response = { data: { link: response.data.url,alt: "fasdf" } }
        resolve(response);
      });
      xhr.addEventListener('error', () => {
        const error = JSON.parse(xhr.responseText);
        reject(error);
      });
    }
  );
};

const onEditorStateChange = (editorState) => {
  dispatch({
    type: `${pageKey}/updateState`,
    payload: {
      editorState
    }
  })
};

<Editor
  editorState={state.editorState}
  wrapperClassName="demo-wrapper"
  editorClassName="demo-editor"
  toolbar={{
    image: { uploadCallback: uploadImageCallBack, alt: { present: false, mandatory: false } },
  }}
  onEditorStateChange={onEditorStateChange}
/>

import React from 'react'
import {Upload} from 'antd';
import {connect} from 'dva'
import { config } from '../utils'
import {Icon} from 'antd';

const UploadButton = () => (
  <div>
    <Icon type="plus" />
    <div className="ant-upload-text">点击上传</div>
  </div>
);

const handleChange = (count) => (fileList) => {
  // 1. Limit the number of uploaded files
  //    Only to show two recent uploaded files, and old ones will be replaced by the new
  fileList = fileList.slice(-count);

  // 2. filter successfully uploaded files according to response from server
  fileList = fileList.filter((file) => {
    if (file.response) {
      if (file.response.code !== 0) {
        return false
      }
    }
    return true;
  });

  // 3. read from response and show file link
  fileList = fileList.map((file) => {
    if (file.response) {
      // Component will show file.url as link
      file.url = file.response.data.url;
    }
    return file;
  });

  return fileList
};

const handleOneChange = (fileList) => {
  return handleChange(1)(fileList);
};

const normOneFile = (e) => {
  let res = e;
  if (Array.isArray(e)) {
    res = e;
  } else {
    res = e.fileList
  }

  if (res.length < 1) {
    return ""
  } else {
    return res[0].url;
  }
};

const normFile = (e) => {
  let res = e;
  if (Array.isArray(e)) {
    res = e;
  } else {
    res = e.fileList
  }

  if (res.length < 1) {
    return ""
  } else {
    return res.map(function(object, i) {
      return object.url
    });
  }
};

class ImageUploader extends React.Component {
  constructor(props) {
    super(props);

    const value = this.props.value || [];
    this.state = {
      images: value
    };
  }

  componentWillReceiveProps(nextProps) {
    // Should be a controlled component.
    if ('value' in nextProps && !!nextProps.value) {
      const value = nextProps.value;

      // 排除uploading的
      if(!value) return;

      this.setState({
        images: [
          {
            uid: -1,
            name: 'test.png',
            status: 'done',
            url: value
          }
        ]
      });
    }
  }

  render() {
    const handleChangeImp = (info) => {
      const res = handleOneChange(info.fileList)
      this.setState({images: res});

      const onChange = this.props.onChange;
      if (onChange) {
        onChange(res);
      }
    };

    return (<span>
      <Upload name="file" listType="picture-card" 
        fileList={this.state.images} onChange={handleChangeImp} action="/api/v1/upload">
        {
          this.state.images.length >= 1
            ? null
            : <UploadButton/>
        }
      </Upload>
    </span>);
  }
}

class ImageMultiUploader extends React.Component {
  constructor(props) {
    super(props);

    const value = this.props.value || [];
    this.state = {
      images: value
    };
  }

  componentWillReceiveProps(nextProps) {
    // Should be a controlled component.
    if ('value' in nextProps && !!nextProps.value) {
      const value = nextProps.value;

      // 排除uploading的
      const newValue = value.filter(function(item) {
        return (!item);
      });
      if(newValue.length > 0) return

      let image_urls = [];
      value.forEach(function(item, index) {
        image_urls.push({
          uid: -(index + 1),
          name: 'test' + index + '.png',
          status: 'done',
          url: item
        })
      });

      this.setState({images: image_urls});
    }
  }

  render() {
    const handleChangeImp = (count) => (info) => {
      const res = handleChange(count)(info.fileList)

      this.setState({images: res});

      const onChange = this.props.onChange;
      if (onChange) {
        onChange(res);
      }
    };

    return (<span>
      <Upload name="file" listType="picture-card" fileList={this.state.images} 
      onChange={handleChangeImp(this.props.maxImage)} action="/api/v1/upload">
        {
          this.state.images.length >= this.props.maxImage
            ? null
            : <UploadButton/>
        }
      </Upload>
    </span>);
  }
}

module.exports = {
  ImageUploader,
  ImageMultiUploader,
  normOneFile,
  normFile
};

<FormItem
  {...formItemLayout}
  label="照片"
>
  {getFieldDecorator('image_url', {
    initialValue: state.editType === 'create' ? "" : data.image_url,
    getValueFromEvent: normOneFile,
    rules: [
      {
        required: true,
      },
    ],
  })(
    <ImageUploader />
  )}
</FormItem>

if (lastHref !== href) {
  NProgress.start()
  if (!loading.global) {
    NProgress.done()
    lastHref = href
  }
}

import Moment from 'moment';

const getMonthDateRange = (param) => {
  const startDate = Moment([param.year(), param.month()]);

  // Clone the value before .endOf()
  const endDate = Moment(startDate).endOf('month');

  // make sure to call toDate() for plain JavaScript date type
  return { from: startDate, to: endDate };
}

const getCurMonthRange = () => {
  return getMonthDateRange(Moment())
}

module.exports = {
  getMonthDateRange,
  getCurMonthRange,
}

import React from 'react'
import {DatePicker} from 'antd';
import {connect} from 'dva'
import {config} from '../utils'
import {Icon} from 'antd';
import moment from 'moment';
import PropTypes from 'prop-types';
const RangePicker = DatePicker.RangePicker;

class StringDatePicker extends React.Component {
  constructor(props) {
    super(props);

    const value = this.props.value || [];
    this.state = {
      current_value: undefined
    };
  }

  componentWillReceiveProps(nextProps) {
    // Should be a controlled component.
    if ('value' in nextProps) {
      const value = nextProps.value;
      if(value === undefined) return

      if (!value){
        this.setState({current_value: null});
        return;
      }
      const current_value = moment(value, 'YYYY-MM-DD')
      this.setState({current_value});
    }
  }

  render() {
    const handleChange = (value, dateString) => {
      let current_value = null;
      if(!!value){
        current_value = value.format('YYYY-MM-DD');
      }
      this.setState({
        current_value
      })

      const onChange = this.props.onChange;
      if (onChange) {
        onChange(current_value);
      }
    }

    return (
      <span>
      {this.state.current_value !== undefined && <DatePicker
        defaultValue={this.state.current_value}
        onChange={handleChange}
        showToday={true}
      />}
      </span>
    );
  }
}

StringDatePicker.propTypes = {
  value: PropTypes.string
};


class StringRangePicker extends React.Component {
  constructor(props) {
    super(props);

    const value = this.props.value || [];
    this.state = {
      current_value: undefined
    };
  }

  componentWillReceiveProps(nextProps) {
    // Should be a controlled component.
    if ('value' in nextProps) {
      const value = nextProps.value;
      if(value === undefined) return
      if(!!value && value.length > 0){
        const newValue = value.filter(function(item) {
          return (!!item);
        });
        if(newValue.length !== value.length)
          return;
      }


      if (!value){
        this.setState({current_value: []});
        return;
      }
      const current_value = value.map(item=>moment(item, 'YYYY-MM-DD'))
      this.setState({current_value});
    }
  }

  render() {
    const handleChange = (value, dateString) => {
      let current_value = null;
      if(!!value){
        current_value=value.map(item=>item.format('YYYY-MM-DD'))
      }
      this.setState({
        current_value
      })

      const onChange = this.props.onChange;
      if (onChange) {
        onChange(current_value);
      }
    }

    return (
      <span>
      {this.state.current_value !== undefined && <RangePicker
        defaultValue={this.state.current_value}
        onChange={handleChange}
        showToday={true}
      />}
      </span>
    );
  }
}

StringRangePicker.propTypes = {
  value: PropTypes.arrayOf(PropTypes.string)
};

module.exports = {
  StringDatePicker,
  StringRangePicker,
};

import React from 'react'
import {mapKey} from '../../utils/config'
import { Map, Marker } from 'react-amap';

const AMap = ({lng,lat}) => {
  const  plugins = [
    'MapType',
    'Scale',
    'OverView',
  ];

  return (
    <div style={{width:"100%",minHeight:"400px"}}>
      <Map amapkey={mapKey}
           plugins={plugins}
           zoom={15}
           center={{longitude: lng, latitude: lat}}
      >
        <Marker position={{longitude: lng, latitude: lat}} />
      </Map>
    </div>
  )
};

export default AMap

const Routers = function ({history, app}) {
  const error = dynamic({
    app,
    component: () => import('./routes/error'),
  });
  const routes = [
    {
      path: route.users,
      models: () => [import('./models/user/index')],
      component: () => import('./routes/user/index'),
    },{
      path: route.userLogin,
      component: () => import('./routes/login/'),
    }
  ];

  return (
    <ConnectedRouter history={history}>
      <App>
        <Switch>
          <Route exact path="/" render={() => (<Redirect to="/user"/>)}/>
          {
            routes.map(({path, ...dynamics}, key) => (
              <Route key={key}
                     exact
                     path={path}
                     component={dynamic({
                       app,
                       ...dynamics,
                     })}
              />
            ))
          }
          <Route component={error}/>
        </Switch>
      </App>
    </ConnectedRouter>
  )
};

/* global window */
import React from 'react'
import NProgress from 'nprogress'
import PropTypes from 'prop-types'
import pathToRegexp from 'path-to-regexp'
import { connect } from 'dva'
import { Layout, Loader } from 'components'
import { classnames, config } from 'utils'
import { Helmet } from 'react-helmet'
import { withRouter } from 'dva/router'
import '../themes/index.less'
import './app.less'
import Error from './error'

const { prefix, openPages,name } = config

const { Header, Bread, Footer, Sider, styles } = Layout
let lastHref

const App = ({ children, dispatch, app, loading, location }) => {
  // 顶部进度条
  if (lastHref !== href) {
    NProgress.start()
    if (!loading.global) {
      NProgress.done()
      lastHref = href
    }
  }

  if (openPages && openPages.includes(pathname)) {
	// 对于特殊的页面，比如login，直接返回Page内容，而不在外面包含公用的组件
    return (<div>
      <Loader fullScreen spinning={loading.effects['app/query']} />
      {children}
    </div>)
  }
  return (
    <div>
      {/* 全局的loading效果 */}
      <Loader fullScreen spinning={loading.effects['app/query']} />
      {/* html title、配置等 */}
      <Helmet>
        <title>{ name }</title>
        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
        <link rel="icon" href={logo} type="image/x-icon" />
        {iconFontJS && <script src={iconFontJS} />}
        {iconFontCSS && <link rel="stylesheet" href={iconFontCSS} />}
      </Helmet>
      <div className={classnames(styles.layout, { [styles.fold]: isNavbar ? false : siderFold }, { [styles.withnavbar]: isNavbar })}>
		// 侧边菜单
        {!isNavbar ? <aside className={classnames(styles.sider, [styles.light])}>
          {siderProps.menu.length === 0 ? null : <Sider {...siderProps} />}
        </aside> : ''}
        <div className={styles.main}>
	      // 顶部导航
          <Header {...headerProps} />
	      // 面包屑菜单
          <Bread {...breadProps} />
		  // 每个页面实际的内容
          <div className={styles.container}>
            <div className={styles.content}>
              {hasPermission ? children : <Error />}
            </div>
          </div>
          // 底部说明
          <Footer />
        </div>
      </div>
    </div>
  )
}

export default withRouter(connect(({ app, loading }) => ({ app, loading }))(App))

setup({dispatch, history}) {
  // Add a response interceptor
  axios.interceptors.response.use(function (response) {
    // Do something with response data
    return response;
  }, function (error) {

  const {response} = error
  let msg;
  let statusCode;
  if (response && response instanceof Object) {
    statusCode = response.status
    if (statusCode === 401) {
      // Do something with response error
      dispatch({
        type: 'unauthorized',
        payload: error,
      })
    }
  }

  return Promise.reject(error);
});

history.listen((location) => {
  dispatch({
    type: 'updateState',
    payload: {
      locationPathname: location.pathname,
      locationQuery: queryString.parse(location.search),
    },
  });

  const match = pathToRegexp(route.userLoginCB).exec(location.pathname)
  if (!match) {
    dispatch({type: 'query'})
  }
});

* query({
          payload,
        }, {call, put, select}) {

  const {locationPathname, locationQuery} = yield select(_ => _.app);
  // 如果不是登录页，那么如果存在就不再查询
  const match = pathToRegexp(route.userLogin).exec(locationPathname);
  if (!match) {
    const {user} = yield select(_ => _.app);
    if ("id" in user) {
      return
    }
  }

  const {data} = yield call(query, payload);
  if (data) {
    const menuData = yield call(menusService.services.query);
    let user = data
    let menu = menuData.data;
    let visit = menu.map(item => item.id);
    yield put({
      type: 'updateState',
      payload: {
        user,
        menu,
      },
    });

    if (locationPathname === route.userLogin) {
      if (locationQuery["url"]) {
        window.location.assign(locationQuery["url"]);
      } else {
        yield put(routerRedux.replace({
          pathname: indexPage,
        }))
      }
    }
  } else if (config.openPages && config.openPages.indexOf(locationPathname) < 0) {
    yield put(routerRedux.push({
      pathname: route.userLogin,
      search: queryString.stringify({
        from: locationPathname,
      }),
    }))
  }
},


* unauthorized(action, {put, select}) {
  const {locationPathname} = yield select(_ => _.app)
  if (locationPathname !== route.userLogin) {
    yield put(routerRedux.push({
      pathname: route.userLogin,
      search: queryString.stringify({
        url: window.location.href
      }),
    }))
  }
},

import React from 'react'
import PropTypes from 'prop-types'
import { Breadcrumb, Icon } from 'antd'
import { Link } from 'react-router-dom'
import pathToRegexp from 'path-to-regexp'
import { queryArray } from 'utils'
import styles from './Bread.less'
import {parseUrl,buildUrl} from '../../utils/url'

const Bread = ({ menu, location }) => {
  // 匹配当前路由
  let pathArray = []
  let current;
  let match;
  for (let index in menu) {
    if (menu[index].route) {
      match = pathToRegexp(menu[index].route).exec(location.pathname);
      if(match){
        current = menu[index];
        break
      }
    }
  }

  const getPathArray = (item) => {
    pathArray.unshift(item);
    if (item.pid) {
      getPathArray(queryArray(menu, item.pid, 'id'))
    }
  };

  if (!current) {
    pathArray.push(menu[0] || {
      id: 1,
      icon: 'laptop',
      name: 'Dashboard',
    });
    pathArray.push({
      id: 404,
      name: 'Not Found',
    })
  } else {
    getPathArray(current)
  }

  // 自动填充
  if(current){
    const urlDatas = parseUrl(location.pathname, current.route);
    pathArray.forEach(function (item) {
      if(item === current || !item.route) return;
      item.route2 = buildUrl(item.route,urlDatas)
    })
  }

  // 递归查找父级
  const breads = pathArray.map((item, key) => {
    const content = (
      <span>{item.icon
        ? <Icon type={item.icon} style={{ marginRight: 4 }} />
        : ''}{item.name}</span>
    )
    return (
      <Breadcrumb.Item key={key}>
        {((pathArray.length - 1) !== key && "route" in item)
          ? <Link to={item.route2 || '#'}>
            {content}
          </Link>
          : content}
      </Breadcrumb.Item>
    )
  })

  return (
    <div className={styles.bread}>
      <Breadcrumb>
        {breads}
      </Breadcrumb>
    </div>
  )
}

Bread.propTypes = {
  menu: PropTypes.array,
  location: PropTypes.object,
}

export default Bread

import React from 'react'
import {Cascader} from 'antd';
import {connect} from 'dva'
import { config } from '../utils'

class Geography extends React.Component {
  constructor(props) {
    super(props);

    this.state = {
      options: [],
      current_province: null,
      current_city: null,
      current_area: null,
      default_value: null
    };
  }

  updateConfig(){
    let options = [];
    const {provinces,citys,areas} = this.props
    const state = this.state

    if(!!provinces){
      provinces.forEach(function (item) {
        options.push({
          value: item.id,
          label: item.fullname,
          isLeaf: false,
          type: 'province',
          data: item,
        })
      })
    }

    let currentCitys = null;
    if(!!state.current_province && !!citys) {
      options.find(function(province){
        if(province.value == state.current_province){
          let tmp_citys = []
          citys.forEach(function (item) {
            tmp_citys.push({
              value: item.id,
              label: item.fullname,
              isLeaf: false,
              type: 'city',
              data: item,
            })
          })
          currentCitys = tmp_citys;
          province.children = tmp_citys;
          return true;
        }else{
          return false;
        }
      })
    }

    if(!!currentCitys && !!state.current_city && !!areas){
      currentCitys.find(function(city){
        if(city.value == state.current_city){
          let tmp_areas = []
          areas.forEach(function (item) {
            tmp_areas.push({
              value: item.id,
              label: item.fullname,
              isLeaf: true,
              type: 'area',
              data: item,
            })
          })
          city.children = tmp_areas;
          return true;
        }else{
          return false;
        }
      })
    }

    this.setState({
      options,
    })
  }

  componentWillReceiveProps(nextProps) {
    // Should be a controlled component.
    if (this.state.default_value === null && 'value' in nextProps) {
      let value = nextProps.value
      if(!value){
        value = []
      }

      if(value.length > 0){
        const newValue = value.filter(function(item) {
          return (!!item);
        });
        if(newValue.length !== value.length)
          return;
      }

      this.props.initGeography(value);

      let current_province = null;
      let current_city = null;
      let current_area = null;
      if(nextProps.value.length === 3){
        current_province = nextProps.value[0];
        current_city = nextProps.value[1];
        current_area = nextProps.value[2];
      }

      this.setState({
        default_value: value,
        current_province,
        current_city,
        current_area
      })
    }

    if(this.state.default_value !== null)
      this.updateConfig()
  }

  render() {
    const  loadData = (selectedOptions) => {
      const targetOption = selectedOptions[selectedOptions.length - 1];
      targetOption.loading = true;
      if(targetOption.type == 'province'){
        this.props.getCitys(targetOption.data);
        this.setState({
          current_province: targetOption.data.id,
        })
      }else if(targetOption.type == 'city'){
        this.props.getAreas(targetOption.data);
        this.setState({
          current_city: targetOption.data.id,
        })
      }
      targetOption.loading = false;
    }

    const onChange = (value, selectedOptions) => {
      if(selectedOptions.length == 3 || selectedOptions.length == 0){
        const onChange = this.props.onChange;
        if(selectedOptions.length == 3){
          this.setState({
            current_province: selectedOptions[0].data.id,
            current_city: selectedOptions[1].data.id,
            current_area: selectedOptions[2].data.id,
          })
          if (onChange) {
            onChange(selectedOptions.map(x=>x.data.id));
          }
        }else{
          this.setState({
            current_province: null,
            current_city: null,
            current_area: null,
          })
          if (onChange) {
            onChange([]);
          }
        }
      }
    }

    return (<span>
      {(this.state.options.length > 0 && <Cascader
            defaultValue={this.state.default_value}
            onChange={onChange}
            options={this.state.options}
            loadData={loadData}
            changeOnSelect
          />)}
    </span>);
  }
}


module.exports = {
  Geography
};

import modelExtend from 'dva-model-extend'
import * as share from '../services/share'
import {model} from './common'

const geographyModel = modelExtend(model, {
  state: {
    provinces: [],
    citys: [],
    areas: [],
  },

  effects: {
    * provinces({payload}, {call, put}) {
      const {data} = yield call(share.provinces, {});
      yield put({
        type: 'updateState',
        payload: {
          provinces: data,
        },
      })
    },

    * citys({payload}, {call, put}) {
      const {data} = yield call(share.citys, payload);
      yield put({
        type: 'updateState',
        payload: {
          citys: data,
        },
      })
    },

    * areas({payload}, {call, put}) {
      const {data} = yield call(share.areas, payload);
      yield put({
        type: 'updateState',
        payload: {
          areas: data,
        },
      })
    },

    * selectProvince({payload}, {call, put}) {
      yield put({
        type: 'citys',
        payload: payload['id'],
      });

      yield put({
        type: 'updateState',
        payload: {
          current_province: payload,
        },
      });
    },

    * selectCity({payload}, {call, put}) {
      yield put({
        type: 'areas',
        payload: payload['id'],
      });

      yield put({
        type: 'updateState',
        payload: {
          current_city: payload,
        },
      });
    },

    * initGeography({payload}, {call, put}) {
      let res = yield call(share.provinces, {});
      const provinces = res.data

      // 若没有默认值，只get省份列表
      if(!payload || payload.length != 3){
        yield put({
          type: 'updateState',
          payload: {
            provinces,
            citys: [],
            areas: [],
          },
        })
        return
      }

      const province_id = parseInt(payload[0]);
      const city_id = parseInt(payload[1])
      const area_id = parseInt(payload[2])

      // 默认省份是否匹配
      let current_province = null;
      provinces.find(function(province){
        if(province.id == province_id){
          current_province = province;
          return true
        }else{
          return false
        }
      })
      if(!current_province) return

      // 找到匹配的省份，get 市区
      res = yield call(share.citys, current_province.id);
      const citys = res.data

      let current_city = null;
      citys.find(function(city){
        if(city.id == city_id){
          current_city = city;
          return true
        }else{
          return false
        }
      })
      if(!current_city) return

      res = yield call(share.areas, current_city.id);
      const areas = res.data

      let current_area = null;
      areas.find(function(area){
        if(area.id == area_id){
          current_area = area;
          return true
        }else{
          return false
        }
      })
      if(!current_area) return

      yield put({
        type: 'updateState',
        payload: {
          provinces,
          citys,
          areas,
        },
      })
    },
  },

  reducers: {
    clearGeography(state,{ payload }) {
      return {
        ...state,
        provinces: [],
        citys: [],
        areas: [],
      }
    },
  },

});

module.exports = {
  geographyModel,
};

const geographyProps = {
  provinces: state.provinces,
  citys: state.citys,
  areas: state.areas,
  initGeography(item) {
    dispatch({
      type: `${pageKey}/initGeography`,
      payload: item
    })
  },
  getCitys(item) {
    dispatch({
      type: `${pageKey}/selectProvince`,
      payload: item
    })
  },
  getAreas (item) {
    dispatch({
      type: `${pageKey}/selectCity`,
      payload: item
    })
  },
};

export default modelExtend(geographyModel, {

<FormItem
  label="位置"
  required
  {...formItemLayout}
>
  {getFieldDecorator('geography', {
    initialValue: state.editType === 'create' ? "" : [data.province_code,data.city_code,data.area_code],
    rules: [
      {
        required: true,
      }],
  })(
    <Geography {...geographyProps} />
  )}
</FormItem>

(function () {
    var params = {};
    //Document对象数据
    if(document) {
        params.domain = document.domain || ''; 
        params.url = document.URL || ''; 
        params.title = document.title || ''; 
        params.referrer = document.referrer || ''; 
    }   
    //Window对象数据
    if(window && window.screen) {
        params.sh = window.screen.height || 0;
        params.sw = window.screen.width || 0;
        params.cd = window.screen.colorDepth || 0;
    }   
    //navigator对象数据
    if(navigator) {
        params.lang = navigator.language || ''; 
    }   
    //解析_maq配置
    if(_maq) {
        for(var i in _maq) {
            switch(_maq[i][0]) {
                case '_setAccount':
                    params.account = _maq[i][1];
                    break;
                default:
                    break;
            }   
        }   
    }   
    //拼接参数串
    var args = ''; 
    for(var i in params) {
        if(args != '') {
            args += '&';
        }   
        args += i + '=' + encodeURIComponent(params[i]);
    }   
 
    //通过Image对象请求后端脚本
    var img = new Image(1, 1); 
    img.src = '/1.gif?' + args;
})();