def post(self, request):
E = ED()
E.u, E.k = -1, 1
E.au, E.uni, E.already, E.not_found = 2, 3, 4, 5
if not request.session.get('is_login', False):
return E.au
u = User.get_via_encoded_id(request.session['uid'])
if u is None:
return E.au
# todo: 更多权限判断
kwargs: dict = json.loads(request.body)
if kwargs.keys() != {'id', 'type', 'pfid'}:
return E.k
e = Entity.get_via_encoded_id(kwargs['id'])
if e is None:
return E.u
fa = Entity.get_via_encoded_id(kwargs['pfid'])
if fa is None or fa.is_doc():
return E.not_found
if e.father is not None and e.father.id == fa.id:
return E.already
if fa.sons_dup_name(e.name):
return E.uni
e.replicate(u, fa)
return 0
def test_post_create_with_valid_referral_attr(self):
user = self.admin_login()
entity = Entity(name='test-entity', created_user=user)
entity.save()
params = {
'name': 'hoge',
'note': 'fuga',
'is_toplevel': False,
'attrs': [
{'name': 'a', 'type': str(AttrTypeObj), 'ref_ids': [entity.id],
'is_delete_in_chain': True, 'is_mandatory': False, 'row_index': '1'},
{'name': 'b', 'type': str(AttrTypeArrObj), 'ref_ids': [entity.id],
'is_delete_in_chain': True, 'is_mandatory': False, 'row_index': '2'},
],
}
resp = self.client.post(reverse('entity:do_create'),
json.dumps(params),
'application/json')
self.assertEqual(resp.status_code, 200)
created_entity = Entity.objects.get(name='hoge')
self.assertEqual(created_entity.attrs.count(), 2)
self.assertEqual([x.name for x in created_entity.attrs.all()], ['a', 'b'])
self.assertFalse(any([x.is_mandatory for x in created_entity.attrs.all()]))
self.assertTrue(all([x.is_delete_in_chain for x in created_entity.attrs.all()]))
def post(self, request):
E = ED()
E.u, E.k = -1, 1
E.au, E.no_fa, E.inv_name, E.rename = 2, 3, 4, 5
if not request.session.get('is_login', False):
return '', E.au
u = User.get_via_encoded_id(request.session['uid'])
if u is None:
return '', E.au
kwargs: dict = {'pfid': None}
kwargs.update(json.loads(request.body))
if kwargs.keys() != {'name', 'pfid', 'type'}:
return '', E.k
name, pfid, type = kwargs['name'], kwargs['pfid'], kwargs['type']
fa = Entity.get_via_encoded_id(pfid) if pfid is not None else u.root
if fa is None:
return '', E.no_fa
if fa.sons_dup_name(name):
return '', E.rename
e = Entity(name=name, father=fa, type=type)
try:
e.save()
except:
return '', E.u
record_create(u, e)
return e.encoded_id, 0
def test_make_entity(self):
entity = Entity(name='test01', created_user=self._test_user)
entity.save()
self.assertEqual(entity.name, 'test01')
self.assertEqual(list(entity.attrs.all()), [])
self.assertTrue(entity.is_active)
def test_index_with_objects(self):
user = self.admin_login()
entity = Entity(name='test-entity', created_user=user)
entity.save()
resp = self.client.get(reverse('entity:index'))
self.assertEqual(resp.status_code, 200)
def test_set_parent(self):
entity = Entity(name='test01', created_user=self._test_user)
entity.save()
attr_base = EntityAttr(name='hoge',
created_user=self._test_user,
parent_entity=entity)
attr_base.save()
self.assertEqual(attr_base.parent_entity, entity)
def test_make_attrbase(self):
entity = Entity(name='test01', created_user=self._test_user)
entity.save()
attr_base = EntityAttr(name='hoge',
created_user=self._test_user,
parent_entity=entity)
attr_base.save()
self.assertEqual(attr_base.name, 'hoge')
self.assertTrue(isinstance(attr_base.type, int))
self.assertEqual(attr_base.referral.count(), 0)
def test_index_with_objects(self):
user = self.admin_login()
entity = Entity(name='test-entity', created_user=user)
entity.save()
resp = self.client.get(reverse('entity:index'))
self.assertEqual(resp.status_code, 200)
root = ElementTree.fromstring(resp.content.decode('utf-8'))
self.assertIsNotNone(root.find('.//tbody/tr'))
self.assertEqual(len(root.findall('.//tbody/tr')), 1)
def setUp(self):
self._user = User(username='******')
self._user.save()
self._entity = Entity(name='entity', created_user=self._user)
self._entity.save()
self._entity_attr = EntityAttr(name='test',
type=AttrTypeStr,
is_mandatory=True,
created_user=self._user,
parent_entity=self._entity)
self._entity_attr.save()
def test_set_parent(self):
entity = Entity(name="test01", created_user=self._test_user)
entity.save()
attr_base = EntityAttr(
name="hoge",
type=AttrTypeValue["object"],
created_user=self._test_user,
parent_entity=entity,
)
attr_base.save()
self.assertEqual(attr_base.parent_entity, entity)
def test_make_attrbase(self):
entity = Entity(name="test01", created_user=self._test_user)
entity.save()
attr_base = EntityAttr(
name="hoge",
type=AttrTypeValue["object"],
created_user=self._test_user,
parent_entity=entity,
)
attr_base.save()
self.assertEqual(attr_base.name, "hoge")
self.assertTrue(isinstance(attr_base.type, int))
self.assertEqual(attr_base.referral.count(), 0)
def get(self, request):
E = ED()
E.u, E.k = -1, 1
E.au, E.no_ent = 2, 3
if not request.session.get('is_login', False):
return E.au
u = User.get_via_encoded_id(request.session['uid'])
if u is None:
return E.au
kwargs: dict = request.GET
if kwargs.keys() != {'did'}:
return E.k
did = kwargs.get('did')
e = Entity.get_via_encoded_id(did)
if e is None:
return E.no_ent
return (
0,
e.name,
Collection.objects.filter(user=u, ent=e).exists(),
e.create_dt_str,
e.creator.encoded_id,
e.creator.name,
e.edit_dt,
e.editor.encoded_id,
e.editor.name,
)
def post(self, request):
E = ED()
E.u, E.k = -1, 1
E.au, E.inv_name, E.inv_cont, E.rename = 2, 3, 4, 5
if not request.session.get('is_login', False):
return E.au
u = User.get_via_encoded_id(request.session['uid'])
if u is None:
return E.au
kwargs: dict = json.loads(request.body)
if kwargs.keys() != {'did', 'content'}:
return E.k
did, content = kwargs['did'], kwargs['content']
e = Entity.get_via_encoded_id(did)
if e is None:
return E.u
e.content = content
try:
e.save()
except:
return E.u
return 0
def test_import_without_permission_parameter(self):
user = User.objects.create(username='******')
entity = Entity(name='origin_name', created_user=user, is_public=False)
entity.save()
EntityResource.import_data_from_request(
{
'id': entity.id,
'name': 'changed_name',
'note': 'changed_note',
'created_user': entity.created_user.username
}, self._test_user)
self.assertEqual(Entity.objects.count(), 1)
self.assertEqual(Entity.objects.last().name, 'origin_name')
def post(self, request):
E = ED()
E.u, E.k = -1, 1
E.au, E.uni, E.too_long = 2, 3, 4
if not request.session.get('is_login', False):
return E.au
u = User.get_via_encoded_id(request.session['uid'])
if u is None:
return E.au
# todo: 更多权限判断
kwargs: dict = json.loads(request.body)
if kwargs.keys() != {'id', 'type', 'name'}:
return E.k
name = kwargs['name']
if not CHECK_ENAME(name):
return E.too_long
e = Entity.get_via_encoded_id(kwargs['id'])
if e is None:
return E.u
if e.brothers_dup_name(name):
return E.uni
e.name = name
e.save()
return 0
def post(self, request):
E = ED()
E.u, E.k = -1, 1
E.au, E.no_id = 2, 3
if not request.session.get('is_login', False):
return E.au
u = User.get_via_encoded_id(request.session['uid'])
if u is None:
return E.au
# todo: 更多权限判断
kwargs: dict = json.loads(request.body)
if kwargs.keys() != {'id', 'type'}:
return E.k
e = Entity.get_via_encoded_id(kwargs['id'])
if e is None:
return E.u
q = Links.objects.filter(user=u, ent=e)
if q.exists():
q.delete()
else:
return E.no_id
return 0
def post(self, request):
E = EasyDict()
E.uk = -1
E.key, E.auth, E.root = 1, 2, 3
kwargs: dict = json.loads(request.body)
if kwargs.keys() != {'fid'}:
return None, E.key
if not request.session['is_login']:
return None, E.auth
try:
user = User.objects.get(id=int(decode(request.session['uid'])))
entity = Entity.get_via_encoded_id(kwargs['fid'])
except:
return None, E.uk
if not entity.can_convert_to_team():
return None, E.root
try:
team = Team.objects.create(root=entity)
Member.objects.create(member=user, team=team, auth='owner')
entity.father = None
entity.name = team.name + ROOT_SUFFIX
entity.save()
record_create(user, entity, delete=True)
except:
return None, E.uk
return team.id, 0
def test_import_with_updating_object(self):
entity = Entity(name='test01',
note='note1',
created_user=self._test_user)
entity.save()
EntityResource.import_data_from_request(
{
'id': entity.id,
'name': 'changed_name',
'note': 'changed_note',
'created_user': entity.created_user.username
}, self._test_user)
self.assertEqual(Entity.objects.count(), 1)
self.assertEqual(Entity.objects.last().name, 'changed_name')
self.assertEqual(Entity.objects.last().note, 'changed_note')
self.assertEqual(Entity.objects.last().created_user, self._test_user)
def test_import_with_updating_object(self):
entity = Entity(name="test01",
note="note1",
created_user=self._test_user)
entity.save()
EntityResource.import_data_from_request(
{
"id": entity.id,
"name": "changed_name",
"note": "changed_note",
"created_user": entity.created_user.username,
},
self._test_user,
)
self.assertEqual(Entity.objects.count(), 1)
self.assertEqual(Entity.objects.last().name, "changed_name")
self.assertEqual(Entity.objects.last().note, "changed_note")
self.assertEqual(Entity.objects.last().created_user, self._test_user)
def get(self, request):
E = ED()
E.u, E.k = -1, 1
E.au, E.no_f = 2, 3
if not request.session.get('is_login', False):
return E.au, '', [], []
u = User.get_via_encoded_id(request.session['uid'])
if u is None:
return E.au, '', [], []
kwargs = request.GET
if kwargs.keys() != {'fid'}:
return E.k, '', [], []
e = Entity.get_via_encoded_id(kwargs.get('fid'))
if e is None:
return E.no_f, '', [], []
path: List[Entity] = e.path
sons: List[Tuple[Entity,
bool]] = [(s, False)
for s in e.sons.filter(is_deleted=False)]
if e.is_user_root():
sons.extend([(lk.ent, True)
for lk in Links.objects.filter(user=u)])
print('==' * 20, f'apply for {sons}')
path_s = [{'fid': f.encoded_id, 'name': f.name} for f in path]
sons_s = [{
'type':
f.type,
'id':
f.encoded_id,
'name':
f.name,
'is_link':
is_link,
'is_starred':
Collection.objects.filter(user=u, ent=f).exists(),
'create_dt':
f.create_dt_str,
'cuid':
f.creator.encoded_id,
'cname':
f.creator.name,
'edit_dt':
f.edit_dt,
'euid':
f.editor.encoded_id,
'ename':
f.editor.name,
} for f, is_link in sons]
return 0, cur_time(), path_s, sons_s, e.name
def get(self, request):
E = ED()
E.u, E.k = -1, 1
E.au, E.no_ent = 2, 3
if not request.session.get('is_login', False):
return E.au
u = User.get_via_encoded_id(request.session['uid'])
if u is None:
return E.au
kwargs: dict = request.GET
if kwargs.keys() != {'did'}:
return E.k
did = kwargs.get('did')
e = Entity.get_via_encoded_id(did)
if e is None:
return E.no_ent
return 0, e.is_locked
def get(self, request):
E = ED()
E.u, E.k = -1, 1
E.au, E.no, E.no_father = 2, 3, 4
if not request.session.get('is_login', False):
return E.au, ''
u = User.get_via_encoded_id(request.session['uid'])
if u is None:
return E.au, ''
kwargs = request.GET
if kwargs.keys() != {'id', 'type'}:
return E.k, ''
e = Entity.get_via_encoded_id(kwargs.get('id'))
if e is None:
return E.no, ''
if e.father is None:
return E.no_father, ''
return 0, e.father.encoded_id
def post(self, request):
E = EasyDict()
E.uk = -1
E.key, E.acc, E.pwd, E.code, E.name, E.uni = 1, 2, 3, 4, 5, 6
kwargs: dict = json.loads(request.body)
if kwargs.keys() != {'acc', 'ver_code', 'pwd', 'name'}:
return E.key,
if not CHECK_ACC(kwargs['acc']):
return E.acc,
if not CHECK_PWD(kwargs['pwd']):
return E.pwd,
if not CHECK_NAME(kwargs['name']):
return E.name,
kwargs.update({'pwd': hash_password(kwargs['pwd'])})
kwargs.update({'portrait': DEFAULT_PROFILE_ROOT + '\handsome.jpg'})
er = EmailRecord.objects.filter(code=kwargs['ver_code'], acc=kwargs['acc'])
if not er.exists():
return E.code
er = er.get()
kwargs.pop('ver_code')
if datetime.now() < er.expire_time:
try:
# print(kwargs)
root = Entity.locate_root(name=kwargs['name'])
u = User.objects.create(root=root, **kwargs)
except IntegrityError:
return E.uni, # 字段unique未满足
except DataError as e:
return E.uk, # 诸如某个CharField超过了max_len的错误
except:
return E.uk,
request.session['is_login'] = True
request.session['uid'] = encode(u.id)
# print(u.portrait.path)
return 0,
else:
return 7
def post(self, request):
E = ED()
E.u, E.k = -1, 1
E.au, E.no_id = 2, 3
if not request.session.get('is_login', False):
return E.au
u = User.get_via_encoded_id(request.session['uid'])
if u is None:
return E.au
# todo: 更多权限判断
kwargs: dict = json.loads(request.body)
if kwargs.keys() != {'id', 'type'}:
return E.k
e = Entity.get_via_encoded_id(kwargs['id'])
if e is None:
return E.no_id
e.is_deleted = True
e.delete_dt = datetime.now()
e.save()
return 0
def post(self, request):
E = ED()
E.u, E.k = -1, 1
E.au, E.uni, E.no_id = 2, 3, 4
if not request.session.get('is_login', False):
return E.au
u = User.get_via_encoded_id(request.session['uid'])
if u is None:
return E.au
# todo: 更多权限判断
kwargs: dict = json.loads(request.body)
if kwargs.keys() != {'id', 'type'}:
return E.k
e = Entity.get_via_encoded_id(kwargs['id'])
if e is None:
return E.u
if u.links.filter(ent__name=e.name):
return E.uni
Links.objects.create(user=u, ent=e)
return 0
def post(self, request):
E = EasyDict()
E.uk = -1
E.key, E.auth, E.name = 1, 2, 3
kwargs: dict = json.loads(request.body)
if kwargs.keys() != {'name'}:
return E.key
if not request.session['is_login']:
return E.auth
try:
owner = User.objects.get(id=int(decode(request.session['uid'])))
except:
return E.auth
if not (0 <= len(str(kwargs['name'])) <= TEAM_NAME_MAX_LENGTH and str(kwargs['name']).isprintable()):
return E.name
try:
# 创建新根文件夹
root = Entity.locate_root(kwargs['name'])
team = Team.objects.create(name=kwargs['name'], root=root)
Member.objects.create(team=team, member=owner, auth='owner')
except:
return E.uk
return 0
def get(self, request):
E = ED()
E.u, E.k = -1, 1
E.au, E.no = 2, 3
if not request.session.get('is_login', False):
return E.au
u = User.get_via_encoded_id(request.session['uid'])
if u is None:
return E.au
# todo: 更多权限判断
kwargs = request.GET
if kwargs.keys() != {'did'}:
return E.k
e = Entity.get_via_encoded_id(kwargs.get('did'))
if e is None or e.father is None:
return E.no
return (0, e.name, len(e.plain_content), e.creator.encoded_id,
e.creator.name, e.is_locked, [{
'fid': f.encoded_id,
'name': f.name
} for f in e.path])
def post(self, request):
u = User.objects.filter(id=int(decode(request.session['uid'])))
if not u.exists():
return -1
u = u.get()
kwargs: dict = json.loads(request.body)
if kwargs.keys() != {'id', 'type', 'is_starred'}:
return 1,
ent = Entity.get_via_encoded_id(kwargs['id'])
if ent is None:
return 3
if kwargs['is_starred']:
try:
Collection.objects.create(user=u, ent=ent)
except:
return -1
return 0
else:
Collection.objects.filter(
ent=ent, user_id=int(decode(request.session['uid']))).delete()
return 0
def post(self, request):
E = ED()
E.u, E.k = -1, 1
E.au, E.no_ent = 2, 3
if not request.session.get('is_login', False):
return E.au
u = User.get_via_encoded_id(request.session['uid'])
if u is None:
return E.au
kwargs: dict = json.loads(request.body)
if kwargs.keys() != {'did', 'is_locked'}:
return E.k
did, is_locked = kwargs['did'], kwargs['is_locked']
e = Entity.get_via_encoded_id(did)
if e is None:
return E.no_ent
e.is_locked = is_locked
try:
e.save()
except:
return E.u
return 0
def process_file(self, filename, user):
trip = Trip()
trip.archive_uri = filename
trip.metadata['original_name'] = os.path.splitext(
os.path.split(filename)[1])[0]
filename_data = re.match(RE_FROM_FILENAME,
trip.metadata['original_name'])
# Open the file
mat = sio.loadmat(filename, squeeze_me=True, struct_as_record=False)
# Find where the recording rate syncs with the recorded GPS time.
sync_idx = _acquire_time_sync_idx(mat['GMT_SEC'].data)
if sync_idx is None:
sync_idx = 0 # But load the data.
trip.metadata['time_sync'] = False
else:
trip.metadata['time_sync'] = True
try:
sync_time = datetime(year=mat['DATE_YEAR'].data[sync_idx],
month=mat['DATE_MONTH'].data[sync_idx],
day=mat['DATE_DAY'].data[sync_idx],
hour=mat['GMT_HOUR'].data[sync_idx],
minute=mat['GMT_MINUTE'].data[sync_idx],
second=mat['GMT_SEC'].data[sync_idx],
tzinfo=timezone.utc)
trip.metadata['time_source'] = 'GMT'
except (KeyError, ValueError):
# Not all flights have a StartTimeVec.
if 'StartTimeVec' in mat:
t = mat['StartTimeVec']
sync_time = datetime(year=t[0],
month=t[1],
day=t[2],
hour=t[3],
minute=t[4],
second=t[5],
tzinfo=timezone.utc)
trip.metadata['time_source'] = 'StartTimeVec'
else:
if filename_data:
sync_time = datetime(
year=int(filename_data.group(year_idx)),
month=int(filename_data.group(mon_idx)),
day=int(filename_data.group(day_idx)),
hour=int(filename_data.group(hour_idx)),
minute=int(filename_data.group(min_idx)),
tzinfo=timezone.utc)
trip.metadata['time_source'] = 'Filename'
else:
raise
# In microseconds
sync_offset = (1 / mat['GMT_SEC'].Rate) * SEC_TO_MICROSEC * sync_idx
start_time = sync_time - timedelta(microseconds=sync_offset)
end_time = start_time
# Organize the data by rate and create a time index for each rate.
d = {} # Time series data
m = {} # Meta data
for p in mat:
param = mat[p]
if isinstance(param, sio.matlab.mio5_params.mat_struct):
if param.Rate not in d:
d[param.Rate] = {
'p': {},
't':
pd.date_range(start_time,
periods=len(param.data),
freq='{}U'.format(
int(SEC_TO_MICROSEC *
(1.0 / param.Rate))),
tz=timezone.utc,
name='timestamp'),
'm': {},
}
if d[param.Rate]['t'][-1] > end_time:
end_time = d[param.Rate]['t'][-1].to_datetime()
d[param.Rate]['p'][p] = param.data
d[param.Rate]['m'][p] = {
'rate': param.Rate,
'units': param.Units if len(param.Units) > 0 else None,
'alpha': param.Alpha,
'description': param.Description
}
else:
if isinstance(param, bytes):
param = param.decode('utf-8')
m[p] = param
# Create a dataframe per data rate.
common_id = filename_data.group(id_idx) if filename_data else None
params = {}
for k, v in d.items():
rate_params = v
params[k] = {
'df': pd.DataFrame(rate_params['p'], index=rate_params['t']),
'meta': rate_params['m']
}
if 'ACID' in params[k]['df'].columns:
common_id = params[k]['df']['ACID'].value_counts().index[0]
# Retrieve or create the entity for this trajectory.
try:
entity = Entity.objects.get(common_id=common_id, owner=user)
except Entity.DoesNotExist:
entity = Entity()
entity.common_id = common_id
entity.physical_id = common_id # Not really what is wanted.
entity.owner = user
entity.loader_config = {
'module': __name__,
}
entity.save()
trip.entity = entity
trip.metadata.update(m)
trip.start_datetime = start_time
trip.duration = end_time - start_time
pos = params[1]['df'][['LONP', 'LATP']].join(params[4]['df'][['ALT']],
how='inner')
# All positional values valid and within the USA for the data
# Occasionally the data goes to 0.351562 and/or zero, especially at
# at the end of the flight.
f = ~(((pos['LONP'] >= -0.4) & (pos['LONP'] <= 0.4)) |
((pos['LATP'] >= -0.4) & (pos['LATP'] <= 0.4)))
pos = pos[f]
positions = [
'{} {} {}'.format(p[1].LONP, p[1].LATP, p[1].ALT)
for p in pos.iterrows() if not (p[1].LONP == 0 or p[1].LATP == 0)
]
trip.geometry = GEOSGeometry('SRID=4326;LINESTRING Z ({})'.format(
','.join(positions)))
trip.save()
for k, v in params.items():
tripdata = TripData()
tripdata.dataframe = v['df']
tripdata.metadata = v['meta']
tripdata.trip = trip
tripdata.save()
def finished(self, db):
pods = Voa.query.filter_by(is_parsed=0).order_by('publish_time').all()
c = LanguageChannel.query.filter_by(name='voa special').first()
if c is None:
print "voa channel is None"
return
for pod in pods:
#print pod.url
r = LanguageResource.query.filter_by(channel_id=c.id, resource_url=pod.url).first()
if r is None:
entity = Entity()
entity.title = pod.title
entity.isa = "english"
to_db.session.add(entity)
to_db.session.commit()
r = LanguageResource()
r.id = entity.id
r.channel_id = c.id
r.study_count = 0
r.dl_count = randint(20,40)
if pod.media:
r.slow_media = pod.media
media_file = "voa_%d.mp3" % r.id
dest_media_file = options.local_media_path + "/static/english/voa/%s" % media_file
dest_media_url = "/static/english/voa/%s" % media_file
dest_tmp_file = "/tmp/voa/%s" % media_file
if not os.path.exists(dest_media_file):
try:
print "download pod media: %s, %s" % (pod.media, dest_tmp_file)
u = urllib.FancyURLopener()
u.retrieve(pod.media, dest_tmp_file)
except IOError as e:
raise e
r.original_media = pod.media
if not os.path.exists(dest_tmp_file):
print "%s not exists" % dest_tmp_file
else:
try:
mv_cmd = "mv %s %s" % (dest_tmp_file, dest_media_file)
print mv_cmd
os.system(mv_cmd)
except Exception, e:
print e
if os.path.exists(dest_media_file):
print dest_media_file
media_md5 = file_md5(dest_media_file)
r.slow_media = "/static/english/voa/%s?md5=%s" % (media_file, media_md5)
r.title = pod.title
r.description = pod.content
r.resource_url = pod.url
r.category = pod.category
r.publish_time = pod.publish_time
to_db.session.add(r)
to_db.session.commit()
pod.resource_id = r.id
pod.is_parsed = 200
crawldb.session.add(pod)
crawldb.session.commit()
def finished(self, db):
pods = EslPod.query.filter_by(is_parsed=0).order_by('publish_time').all()
c = LanguageChannel.query.filter_by(name='eslpod').first()
if c is None:
print "eslpod channel is None"
return
for pod in pods:
#print pod.url
r = LanguageResource.query.filter_by(channel_id=c.id, resource_url=pod.url).first()
if r is None:
entity = Entity()
entity.title = pod.title
entity.isa = "english"
to_db.session.add(entity)
to_db.session.commit()
r = LanguageResource()
r.id = entity.id
r.channel_id = c.id
r.study_count = 0
r.dl_count = randint(20,40)
title = pod.title.replace(u'–',"").replace(u'-',"").replace(u'\x92',"").replace(u'\x96',"")
r.title = eslpod_title.sub("",title).strip()
print r.title
r.description = pod.content
r.resource_url = pod.url
r.publish_time = pod.publish_time
to_db.session.add(r)
to_db.session.commit()
if pod.media:
media_file = pod.media.split('/')[-1]
normal_media_file = "eslpod_%d.mp3" % r.id # media_file.lower()
#dest_orig_media_file = options.local_media_path + "/static/english/eslpod/%s" % media_file
#dest_orig_media_url = "/static/english/eslpod/%s" % media_file
dest_media_file = options.local_media_path + "/static/english/eslpod/%s" % normal_media_file
dest_media_url = "/static/english/eslpod/%s" % normal_media_file
dest_tmp_file = "/tmp/eslpod/%s" % media_file
if not os.path.exists(dest_media_file):
try:
print "download pod media: %s" % pod.media, dest_media_file
u = urllib.FancyURLopener()
u.retrieve(pod.media, dest_tmp_file)
except IOError as e:
raise e
r.original_media = pod.media
if not os.path.exists(dest_tmp_file):
print "%s not exists" % dest_tmp_file
else:
split_media_file = "split_"+media_file.lower()
dest_split_media_file = "/tmp/eslpod/%s" % (split_media_file)
fast_dialog = pod.fast_dialog
try:
m = re.findall("(\d+):(\d+)", pod.fast_dialog)
if len(m) >= 1 and len(m[0]) >=2:
minu = int(m[0][0])
second = int(m[0][1])
second -= 1
if second < 0:
second=0
fast_dialog = "%d:%d" % (minu, second)
print fast_dialog
else:
print "not find fast_dialog" , pod.fast_dialog
except Exception, e:
print e
pass
if fast_dialog:
start_time = fast_dialog.replace(':', '.')
cmd = "mp3splt -o %s %s %s EOF-0.30" % (split_media_file.split('.')[0], dest_tmp_file, start_time)
try:
print cmd
os.system(cmd)
mv_cmd = "mv %s %s" % (dest_split_media_file, dest_media_file)
print mv_cmd
os.system(mv_cmd)
except Exception, e:
print e
else:
try:
mv_cmd = "mv %s %s" % (dest_tmp_file, dest_media_file)
print mv_cmd
os.system(mv_cmd)
except Exception, e:
print e
