def handle(self, *args, **options):
# Override backup with command line arg value
backup_name = options.get('backup')
if backup_name:
if not isinstance(backup_name, str):
print('Incorrect argument type')
return None
self.backup = backup_name
if self.backup in ["False", "false"]:
print('Skipping Backup')
return None
new_aws_key_name = '%s/mermaid_backup_%s.%s' % (
self.backup, simpleflake(), BACKUP_EXTENSION)
new_backup_filename = '%s_mermaid_backup_%s.%s' % (
self.backup, simpleflake(), BACKUP_EXTENSION)
new_backup_path = os.path.join(self.local_file_location,
new_backup_filename)
self._pg_dump(new_backup_path)
if options.get('no_upload', False) is False:
print('Uploading {0} to S3 bucket {1}'.format(
new_aws_key_name, AWS_BACKUP_BUCKET))
self.s3.upload_file(new_backup_path, AWS_BACKUP_BUCKET,
new_aws_key_name)
print('Backup Complete')
def test_simpleflake_parts_timestamp(self):
coolstamp = SIMPLEFLAKE_EPOCH + 1234321.0
epoch_flake = simpleflake(timestamp=coolstamp)
timestamp = extract_bits(epoch_flake,
SIMPLEFLAKE_TIMESTAMP_SHIFT,
SIMPLEFLAKE_TIMESTAMP_LENGTH)
self.assertEquals(coolstamp, (timestamp / 1000.0) + SIMPLEFLAKE_EPOCH)
def dashboard_send():
app = get_app(g.app_id)
survey_id = create_survey(g.app_id)
survey = get_survey(g.app_id, survey_id)
users = get_users(g.app_id)
sender = str(app["shortcode"])[-4:]
message = "%s\nREPLY WITH %s" % (
survey["question"],
"/".join(get_choices(g.app_id, survey_id)),
)
if users:
for user in users:
access_token = get_user_token(g.app_id, user)
params = dict(access_token=access_token)
payload = json.dumps(dict(
outboundSMSMessageRequest=dict(
clientCorrelator=simpleflake(),
senderAddress="tel:%s" % sender,
outboundSMSTextMessage=dict(
message=message,
),
address=["tel:+63%s" % user],
),
))
# TODO: Check response
requests.post(
"http://devapi.globelabs.com.ph/smsmessaging/v1/outbound/%s/requests" % sender,
headers={"Content-Type": "application/json"},
params=params,
data=payload,
)
flash("Sent survey to %d users" % len(users), "info")
else:
flash("No users subscribed yet", "error")
return redirect(url_for("dashboard"))
def test_simpleflake_parts_random(self):
random_bits = random.getrandbits(5)
flake = sf.simpleflake(random_bits=random_bits)
rand_result = sf.extract_bits(flake,
sf.SIMPLEFLAKE_RANDOM_SHIFT,
sf.SIMPLEFLAKE_RANDOM_LENGTH)
self.assertEquals(random_bits, rand_result)
def post(self):
user = self.get_current_user()
trip = dict()
trip_fields = {
'start_date': 'start_date',
'end_date': 'end_date',
'description': 'description',
'place_id': 'place_id',
'address': 'formatted_address',
'locality': 'locality',
'region': 'administrative_area_level_1',
'county': 'administrative_area_level_2',
'longitude': 'lng',
'latitude': 'lat'
}
for key in trip_fields:
trip[key] = self.get_argument(trip_fields[key], None)
trip_uuid = simpleflake()
trip['trip_id'] = base62().hash(trip_uuid, 12)
trip['created_at'] = r.now()
trip['updated_at'] = r.now()
trip['creator_user_id'] = user['id']
trip['geo'] = r.point(float(trip['longitude']),
float(trip['latitude']))
r.table("trip").insert(trip).run()
self.redirect("/")
def __send(self, message_type, args, message):
data = dict(
message_type=message_type,
mobile_number=args.mobile_number,
shortcode=args.shortcode,
message_id=str(simpleflake()),
message=message,
client_id=current_app.config["CHIKKA_CLIENT_ID"],
secret_key=current_app.config["CHIKKA_SECRET_KEY"],
)
if message_type == "REPLY":
data.update(
request_id=args.request_id,
request_cost="FREE",
)
current_app.logger.debug("Sending message: %r", data)
res = requests.post(CHIKKA_REPLY_ENDPOINT, data=data)
current_app.logger.debug("""
Status code: %r
Body: %r
""", res.status_code, res.content)
if res.status_code != requests.codes.ok:
abort(500)
class Base:
id = db.Column(db.Unicode(),
primary_key=True,
default=lambda: str(simpleflake()))
@classmethod
async def exists(cls: db.Model, id_: str) -> bool:
return bool(await cls.select('id').where(cls.id == id_).gino.scalar())
@classmethod
def get_any(cls: db.Model,
insensitive: Union[bool, List[str]] = False,
**kwargs) -> Gino:
if not kwargs:
raise ValueError('No kwargs provided')
queries = []
if isinstance(insensitive, list):
for k, v in kwargs:
if k in insensitive:
queries.push(func.lower(getattr(cls, k)) == func.lower(v))
else:
queries.push(getattr(cls, k) == v)
elif insensitive is True:
queries = [
func.lower(getattr(cls, k)) == func.lower(v)
for k, v in kwargs.items()
]
else:
queries = [getattr(cls, k) == v for k, v in kwargs.items()]
return cls.query.where(or_(*queries)).gino
def test_simpleflake_parts_random(self):
random_bits = random.getrandbits(5)
flake = sf.simpleflake(random_bits=random_bits)
rand_result = sf.extract_bits(flake,
sf.SIMPLEFLAKE_RANDOM_SHIFT,
sf.SIMPLEFLAKE_RANDOM_LENGTH)
self.assertEquals(random_bits, rand_result)
def post(self):
user = self.get_current_user()
trip = dict()
trip_fields = {
'start_date': 'start_date',
'end_date': 'end_date',
'description': 'description',
'place_id': 'place_id',
'address': 'formatted_address',
'locality': 'locality',
'region': 'administrative_area_level_1',
'county': 'administrative_area_level_2',
'longitude': 'lng',
'latitude': 'lat'
}
for key in trip_fields:
trip[key] = self.get_argument(trip_fields[key], None)
trip_uuid = simpleflake()
trip['trip_id'] = base62().hash(trip_uuid, 12)
trip['created_at'] = r.now()
trip['updated_at'] = r.now()
trip['creator_user_id'] = user['id']
trip['geo'] = r.point(float(trip['longitude']), float(trip['latitude']))
r.table("trip").insert(trip).run()
self.redirect("/")
def __send(self, message_type, args, message):
data = dict(
message_type=message_type,
mobile_number=args.mobile_number,
shortcode=args.shortcode,
message_id=str(simpleflake()),
message=message,
client_id=current_app.config["CHIKKA_CLIENT_ID"],
secret_key=current_app.config["CHIKKA_SECRET_KEY"],
)
if message_type == "REPLY":
data.update(
request_id=args.request_id,
request_cost="FREE",
)
current_app.logger.debug("Sending message: %r", data)
res = requests.post(CHIKKA_REPLY_ENDPOINT, data=data)
current_app.logger.debug("""
Status code: %r
Body: %r
""", res.status_code, res.content)
if res.status_code != requests.codes.ok:
abort(500)
def test_simpleflake_parts_timestamp(self):
coolstamp = sf.SIMPLEFLAKE_EPOCH + 1234321.0
epoch_flake = sf.simpleflake(timestamp=coolstamp)
timestamp = sf.extract_bits(epoch_flake,
sf.SIMPLEFLAKE_TIMESTAMP_SHIFT,
sf.SIMPLEFLAKE_TIMESTAMP_LENGTH)
self.assertEquals(coolstamp,
(timestamp / 1000.0) + sf.SIMPLEFLAKE_EPOCH)
def test_parse(self):
coolstamp = sf.SIMPLEFLAKE_EPOCH + 123123
gen = random.SystemRandom()
random_bits = gen.getrandbits(sf.SIMPLEFLAKE_RANDOM_LENGTH)
flake = sf.simpleflake(timestamp=coolstamp, random_bits=random_bits)
parts = sf.parse_simpleflake(flake)
self.assertEquals(coolstamp, parts.timestamp)
self.assertEquals(random_bits, parts.random_bits)
def test_parse(self):
coolstamp = SIMPLEFLAKE_EPOCH + 123123
random_bits = random.SystemRandom()\
.getrandbits(SIMPLEFLAKE_RANDOM_LENGTH)
flake = simpleflake(timestamp=coolstamp, random_bits=random_bits)
parts = parse_simpleflake(flake)
self.assertEquals(coolstamp, parts.timestamp)
self.assertEquals(random_bits, parts.random_bits)
def create_app():
app_id = simpleflake()
# Store app
db.hmset(key("apps", app_id), dict(
id=app_id,
email=request.form["email"].strip().lower(),
shortcode=int(request.form["shortcode"].strip()),
))
return app_id
def activation(signedstring):
try:
id = int(unsign(signedstring, app.config))
the_user = user.User.get(user.User.id == id)
the_user.status = 1
the_user.auth_token = str(simpleflake())
the_user.save()
session['user_id'] = id
return redirect(url_for('index'))
except (BadSignature, DoesNotExist):
raise BadRequestError()
def post(self):
user = self.get_current_user()
event = dict()
event_fields = [
'title', 'start_date', 'end_date', 'start_time', 'end_time',
'description', 'website'
]
venue = dict()
venue_fields = [
'foursquare_id', 'name', 'address', 'locality', 'region',
'postal_code', 'longitude', 'latitude'
]
for key in event_fields:
event[key] = self.get_argument(key, None)
for key in venue_fields:
venue[key] = self.get_argument(key, None)
event_uuid = simpleflake()
event['event_id'] = base62().hash(event_uuid, 12)
venue_uuid = simpleflake()
venue['venue_id'] = base62().hash(venue_uuid, 12)
event['venue_id'] = venue['venue_id']
event['created_at'] = r.now()
event['updated_at'] = r.now()
event['creator_user_id'] = user['id']
venue['geo'] = r.point(float(venue['longitude']),
float(venue['latitude']))
venue['created_at'] = r.now()
venue['updated_at'] = r.now()
venue['creator_user_id'] = user['id']
r.table("event").insert(event).run()
r.table("venue").insert(venue).run()
self.redirect("/")
def add_sound(lat, lng, basename, title, container, user, flags):
timestamp = int(time())
return Sound.create(id=simpleflake(),
lat=check_float(lat),
lng=check_float(lng),
basename=check_notempty(basename),
title=title,
container=check_notempty(container),
user=user,
flags=flags,
created=timestamp,
modified=timestamp)
def post(self):
user = self.get_current_user()
event = dict()
event_fields = [
'title', 'start_date', 'end_date', 'start_time', 'end_time', 'description',
'website'
]
venue = dict()
venue_fields = [
'foursquare_id', 'name', 'address', 'locality', 'region', 'postal_code',
'longitude', 'latitude'
]
for key in event_fields:
event[key] = self.get_argument(key, None)
for key in venue_fields:
venue[key] = self.get_argument(key, None)
event_uuid = simpleflake()
event['event_id'] = base62().hash(event_uuid, 12)
venue_uuid = simpleflake()
venue['venue_id'] = base62().hash(venue_uuid, 12)
event['venue_id'] = venue['venue_id']
event['created_at'] = r.now()
event['updated_at'] = r.now()
event['creator_user_id'] = user['id']
venue['geo'] = r.point(float(venue['longitude']), float(venue['latitude']))
venue['created_at'] = r.now()
venue['updated_at'] = r.now()
venue['creator_user_id'] = user['id']
r.table("event").insert(event).run()
r.table("venue").insert(venue).run()
self.redirect("/")
def send_sms(mobile_number, message):
requests.post(
CHIKKA_API_URL,
data=dict(
message_type="SEND",
mobile_number=mobile_number,
shortcode=app.config["CHIKKA_SHORTCODE"],
message_id=str(simpleflake()),
message=message + '\n\n*',
client_id=app.config["CHIKKA_CLIENT_ID"],
secret_key=app.config["CHIKKA_SECRET_KEY"],
)
)
def send_sms(mobile_number, message):
requests.post(
CHIKKA_API_URL,
data=dict(
message_type="SEND",
mobile_number=mobile_number,
shortcode=SHORTCODE,
message_id=str(simpleflake()),
message=message,
client_id=CLIENT_ID,
secret_key=SECRET_KEY,
)
)
def links(link_id):
item = Links.query.get(link_id)
current_visit = Visits(visit_id=simpleflake(),
visit_ip=request.headers.get('CF-Connecting-IP'))
try:
db.session.add(current_visit)
db.session.commit()
return redirect(f"http://{item.link_url}")
except:
traceback.print_exc()
return "ip append ooops.."
def create_survey(app_id):
survey_id = simpleflake()
question = request.form["question"].strip()
choices = map(lambda s: s.strip().upper(), request.form["choices"].strip().split("\n"))
# Store survey
db.hmset(key("surveys", app_id, survey_id), dict(
id=survey_id,
question=question,
)),
# Add choices
db.sadd(key("choices", app_id, survey_id), *choices)
# Set current survey
db.set(key("curr_survey", app_id), survey_id)
return survey_id
def upload():
merchant = logged_in()
error = False
desc = request.form.get('desc')
if not desc:
flash("You need to write a description", 'error')
error = True
amount = request.form.get('amount')
if not amount:
flash("You need to specify item's price", 'error')
error = True
file = request.files['file']
if not (file and allowed_file(file.filename)):
flash("Did you forget about your file?", 'error')
error = True
if not error:
filename = secure_filename(file.filename)
filepath=os.path.join(app.config['UPLOAD_FOLDER'], filename)
file.save(filepath)
item_id = simpleflake()
shortcode = merchant['globe_shortcode']
# Save as upload of user
db.sadd(
'{}:items'.format(shortcode),
item_id,
)
# Save upload details
db.hmset(
'{}:items:{}'.format(
shortcode,
item_id,
),
{
'filename': filename,
'filepath': filepath,
'desc': desc,
'amount': amount,
},
)
flash('Item added!', 'success')
return redirect(url_for('dashboard'))
def upload():
merchant = logged_in()
error = False
desc = request.form.get('desc')
if not desc:
flash("You need to write a description", 'error')
error = True
amount = request.form.get('amount')
if not amount:
flash("You need to specify item's price", 'error')
error = True
file = request.files['file']
if not (file and allowed_file(file.filename)):
flash("Did you forget about your file?", 'error')
error = True
if not error:
filename = secure_filename(file.filename)
filepath = os.path.join(app.config['UPLOAD_FOLDER'], filename)
file.save(filepath)
item_id = simpleflake()
shortcode = merchant['globe_shortcode']
# Save as upload of user
db.sadd(
'{}:items'.format(shortcode),
item_id,
)
# Save upload details
db.hmset(
'{}:items:{}'.format(
shortcode,
item_id,
),
{
'filename': filename,
'filepath': filepath,
'desc': desc,
'amount': amount,
},
)
flash('Item added!', 'success')
return redirect(url_for('dashboard'))
def gen_key(cls, code=None):
'''
生成随机带字符串的 code
'''
if code:
return str(code), ''
offset = 4
confuse = str(simpleflake())
index = randint(0, offset)
last = index + offset
code = hashlib.sha224(confuse).hexdigest()[index:last]
return code, confuse
class Base:
"""
Base class for models to inherit from.
Provides default `id` column and `created_at` column, and utility class methods:
`exists`: check if a row exists with given id
`get_any`: gets all rows matching at least one of the given arguments, being optionally case insensitive.
"""
id = db.Column(db.Unicode(),
primary_key=True,
default=lambda: str(simpleflake()))
created_at = db.Column(db.DateTime, default=datetime.utcnow)
@classmethod
async def exists(cls: db.Model, id_: str) -> bool:
"""Check if a model exists with the given id."""
return bool(await cls.select("id").where(cls.id == id_).gino.scalar())
@classmethod
def get_any(cls: db.Model,
insensitive: Union[bool, List[str]] = False,
**kwargs) -> Gino:
"""Get models that match any of the given kwargs, with them optionally being case insensitive."""
if not kwargs:
raise ValueError("No kwargs provided")
queries = []
if isinstance(insensitive, list):
for k, v in kwargs:
if k in insensitive:
queries.push(func.lower(getattr(cls, k)) == func.lower(v))
else:
queries.push(getattr(cls, k) == v)
elif insensitive is True:
queries = [
func.lower(getattr(cls, k)) == func.lower(v)
for k, v in kwargs.items()
]
else:
queries = [getattr(cls, k) == v for k, v in kwargs.items()]
return cls.query.where(or_(*queries)).gino
def invoke(self):
"""
Run the file count application
"""
# Get inputs
directory = self.get_input_data_port(self.__directory_port_name)
recursive = self.get_input_string_port(self.__recursive_port_name, 'n')
recursive = str(recursive).lower() in {'y', 'yes', 'true'}
output_dir = self.get_output_data_port(self.__output_data_port_name)
# Build and the command
args = '{_dir}{_r}'.format(_dir=directory,
_r='' if not recursive else ' -r')
cmd = 'python /src/file_count/file_count.py' + ' ' + args
print('Executing {_cmd}'.format(_cmd=cmd))
os.system(cmd)
if os.path.exists(self.__algo_output_file):
with open(self.__algo_output_file, 'r') as f:
self.__algo_output = json.load(f)
else:
print("Expected output missing.")
return False
# Copy output
if not os.path.exists(output_dir):
os.makedirs(output_dir)
shutil.copy(
'file_count.json',
os.path.join(output_dir,
'file_count_' + str(simpleflake()) + '.json'))
# Create output port
self.set_output_string_port(self.__output_string_port_name,
self.__algo_output['file_count'])
print("Invoke complete")
return True
def submit_comment():
'''
Hit by a user's browser to add a new comment
'''
# slug should be something like a url
slug = request.form.get('slug')
comment_text = request.form.get('comment')
name = request.form.get('name')
email = request.form.get('email')
if not comment_text or not name or not slug:
return jsonify({
'error': '`comment`, `name` and `slug` needed',
}), 400
comment_id = str(simpleflake.simpleflake())
comment = {
'id': comment_id,
'text': comment_text,
'name': name,
'email': email,
'version': '0',
'ip_address': request.remote_addr,
'created_at': datetime.utcnow().replace(tzinfo=pytz.utc).isoformat(),
}
comment_json = json.dumps(comment)
# store comment in appropriate place in bucket
file_name = 'comments/%s/%s.json' % (slug, comment_id)
bucket.put_object(
Body=bytes(comment_json, encoding='utf8'),
Key=file_name,
ACL='private',
ContentType='application/json',
)
return Response(comment_json, headers={
'Access-Control-Allow-Origin': '*',
}, content_type='application/json')
def add_user(username, fullname, password, email):
if not re.match(r'^[a-z\d\-]+$', username, flags=re.I):
raise BadRequestError('Bad username')
if not re.match(r'^[a-z0-9._%+-]+@[a-z0-9.-]+\.[a-z]{2,4}$',
email,
flags=re.I):
raise BadRequestError('Bad email address')
if not len(password) > 7:
raise BadRequestError('Password is too short')
if not re.match(r'[a-z]', fullname, re.I):
raise BadRequestError('Full name appears not to be complete')
timestamp = int(time())
try:
return User.create(id=simpleflake.simpleflake(),
username=username.strip(),
fullname=fullname.strip(),
password=hashlib.sha256(password).hexdigest(),
email=email,
status=0,
created=timestamp,
modified=timestamp)
except IntegrityError:
raise ConflictError('Account already exists')
def post(self, client_id, user_id):
args = self.parser.parse_args()
if args.secret_key != db.hget("apps:" + client_id, "secret_key"):
abort(401)
app_name = db.hget("apps:" + client_id, "name")
user = db.hgetall(
"apps:{}:users:{}".format(client_id, user_id),
)
auth = OtpAuth(args.secret_key)
code = auth.totp()
res = requests.post(
CHIKKA_SMS_ENDPOINT,
data=dict(
message_type="SEND", # Inconsistent
mobile_number=user["number"],
shortcode=current_app.config["CHIKKA_SHORTCODE"],
message_id=simpleflake(),
message="""{}
Code: {}
-
""".format(app_name, code),
request_cost="FREE",
client_id=current_app.config["CHIKKA_CLIENT_ID"],
secret_key=current_app.config["CHIKKA_SECRET_KEY"],
),
)
if res.status_code != requests.codes.ok:
abort(500)
return ""
def invoke(self):
"""
Run the file count application
"""
# Get inputs
directory = self.get_input_data_port(self.__directory_port_name)
recursive = self.get_input_string_port(self.__recursive_port_name, 'n')
recursive = str(recursive).lower() in {'y', 'yes', 'true'}
output_dir = self.get_output_data_port(self.__output_data_port_name)
# Build and the command
args = '{_dir}{_r}'.format(_dir=directory, _r='' if not recursive else ' -r')
cmd = 'python /src/file_count/file_count.py' + ' ' + args
print('Executing {_cmd}'.format(_cmd=cmd))
os.system(cmd)
if os.path.exists(self.__algo_output_file):
with open(self.__algo_output_file, 'r') as f:
self.__algo_output = json.load(f)
else:
print("Expected output missing.")
return False
# Copy output
if not os.path.exists(output_dir):
os.makedirs(output_dir)
shutil.copy('file_count.json', os.path.join(output_dir, 'file_count_' + str(simpleflake()) + '.json'))
# Create output port
self.set_output_string_port(self.__output_string_port_name, self.__algo_output['file_count'])
print("Invoke complete")
return True
def add_session():
"""
Create a "session" by taking the email and password, and returning
an auth token and setting the user ID in the session cookie.
"""
data = form_or_json()
try:
the_user = user.User.get(user.User.email == data['email'])
if the_user.password == hashlib.sha256(data['password']).hexdigest():
session['user_id'] = the_user.id
if the_user.auth_token:
auth_token = the_user.auth_token
else:
auth_token = str(simpleflake())
the_user.auth_token = auth_token
the_user.save()
return jsonify(auth_token=sign(auth_token, app.config),
user_id=str(the_user.id))
else:
raise UnauthorizedError()
except KeyError:
raise BadRequestError()
except DoesNotExist:
raise UnauthorizedError()
def _new_id(self):
"""The identifier for each upload will be a random number
generated by the simpleflake library.
More information at: http://tinyurl.com/mqbjbpm
"""
return str(simpleflake())
def checkpoint(thread_local=__LOCALS):
"""
Reset the checkpoint
"""
thread_local.checkpoint_id = simpleflake.simpleflake()
def charge():
"""
Charge URI is the endpoint for charging and sending of sms
This endpoint expects the ff params:
- shortcode
- subscriber_number
- amount
"""
shortcode = request.json['shortcode']
merchant = db.hgetall(shortcode)
if not merchant:
abort(404)
subscriber_number = request.json['subscriber_number']
item_id = request.json.get('item_id', 'demo')
amount = request.json['amount']
# Get the access token from DB
access_token = db.hget(
'{}:{}'.format(shortcode, subscriber_number),
'access_token',
)
if not access_token:
return jsonify(
needs_authorization=True,
dialog_url=const.G_DIALOG.format(merchant['globe_app_id']),
)
sender = shortcode[-4:] # this is weird!
confirm_code = str(simpleflake())[-6:] # Generate a random code for this user session
params = {'access_token': access_token}
req = {
'outboundSMSMessageRequest': {
'clientCorrelator': str(simpleflake()),
'senderAddress': 'tel:{}'.format(sender),
'outboundSMSTextMessage': {
'message': '{}\n\nYou will be charged PHP {}. This is your code to proceed: {}'.format(
merchant['store_name'],
amount,
confirm_code,
),
},
'address': ['tel:+63{}'.format(subscriber_number)],
}
}
res = requests.post(
const.G_SMS_ENDPOINT.format(sender),
headers={
'Content-Type': 'application/json',
},
params=params,
data=json.dumps(req)
)
app.logger.debug(res.content)
if not res.ok:
abort(500)
payload = res.json()
payload.update(confirm_code_sent=True)
# Save confirm code assoc
# Expires after 15 minutes
confirm_key = '{}:{}:confirm:{}'.format(
shortcode,
subscriber_number,
confirm_code,
)
db.hmset(confirm_key, {
'item_id': item_id,
'amount': amount,
})
db.expire(confirm_key, 15 * 60)
return jsonify(**payload)
def test_simpleflake_size(self):
flake = sf.simpleflake()
self.assertEquals(64, len(sf.binary(flake)))
def store(result, storage=None):
storage = storage or get_storage(name=result.experiment.name)
key = simpleflake()
storage.set(key, result)
return key
def checkpoint(thread_local=__LOCALS):
"""
Reset the checkpoint
"""
thread_local.checkpoint_id = simpleflake.simpleflake()
def __init__(self) -> None:
self.id = simpleflake()
self.components = {}
self.eindex[self.id] = self
db_client = MongoClient('localhost', 27017)
# print(db_client.server_info()) get connection Details
# print("Mongodb Connection Successful")
db = db_client['videoAPI']
user_info = db['userdata']
user_login_info = db['login_info']
video_data = db['video_db']
app = Flask(__name__)
app.debug = True
# Enable debug for Dev Environment
# assign user verification unique id using simpleflake
user_verification_id = simpleflake()
reg_time = datetime.now()
# Enable to share data between java script and python flask .so we use flask CORS
CORS(app)
@app.route('/videoapi/register', methods=['GET', 'POST'])
def user_register():
# check if it is a GET method
if request.method == 'GET':
request_data = request.args
elif request.method == 'POST':
request_data = request.form
else:
def flake_id():
"""Generate a new random Flake ID"""
return simpleflake()
def create_table(self, data):
table_id = simpleflake()
print "".join(["Creating new table, id=", str(table_id)])
return self.update_table(table_id, data)
def put(cls, models):
if not models:
return []
update_models = []
insert_models = []
for model in models:
if '_key' in model.__dict__ and model._key:
update_models.append(model)
else:
insert_models.append(model)
columns = ['key_id', 'namespace']
columns.extend(sorted(cls._properties.keys()))
if insert_models:
row_values = ['%s' for _ in range(len(columns))]
row_values = "({})".format(', '.join(row_values))
values = [row_values for _ in range(len(insert_models))]
args = []
for model in models:
model._key = db.Key.from_path(cls.kind(),
simpleflake(),
namespace='benchmark_test')
row_args = [getattr(model, column) for column in columns]
args.extend(row_args)
args = tuple(args)
sql = "INSERT INTO {table_name} ({columns}) VALUES {values}".format(
table_name=cls.__name__,
columns=', '.join(columns),
values=', '.join(values),
)
with cursor() as db_cursor:
try:
db_cursor.execute("BEGIN")
db_cursor.execute(sql, args)
db_cursor.execute("COMMIT")
except Exception as e:
_logger.error("Failed to execute SQL: {}".format(sql))
_logger.exception(e.message)
db_cursor.execute("ROLLBACK")
raise NotImplementedError("{} / {}".format(sql, args))
if update_models:
for model in update_models:
assignments = [
'{column} = %s'.format(column=column) for column in columns
]
assignments = ', '.join(assignments)
args = [getattr(model, column) for column in columns]
args.append(model._key.id())
args.append(model._key.namespace())
args = tuple(args)
sql = "UPDATE {table_name} SET {assignments} WHERE key_id = %s AND namespace = %s".format(
table_name=cls.__name__,
assignments=assignments,
)
with cursor() as db_cursor:
try:
db_cursor.execute("BEGIN")
db_cursor.execute(sql, args)
db_cursor.execute("COMMIT")
except Exception as e:
_logger.error("Failed to execute SQL: {}".format(sql))
_logger.exception(e.message)
db_cursor.execute("ROLLBACK")
raise NotImplementedError("{} / {}".format(sql, args))
def store(result, storage=None):
storage = storage or get_storage(name=result.experiment.name)
key = simpleflake()
storage.set(key, result)
return key
def _new_id(self):
'''The identifier for each upload will be a random number
generated by the simpleflake library.
More information at: http://tinyurl.com/mqbjbpm
'''
return str(simpleflake())
from sqlalchemy import create_engine, Table, Column, Integer, Text, String, DateTime, MetaData
from datetime import datetime
from simpleflake import simpleflake
engine = create_engine('sqlite:///local.db', echo = True)
meta = MetaData()
user = Table(
'users',
meta,
Column('id', Integer, primary_key = True),
Column('username', String(16), nullable = False),
Column('password', String(512), nullable = False),
Column('email', String(64), nullable = False),
Column('reg_time', DateTime, default = datetime.utcnow)
)
message = Table(
'messages',
meta,
Column('id', Integer, primary_key = True, default = simpleflake()),
Column('username', String(16), nullable = False),
Column('message', Text, nullable = False),
Column('sent_at', DateTime, default = datetime.utcnow)
)
meta.create_all(engine)
def get_unique_id(**kwargs):
kwargs.setdefault('epoch', settings.JANGL_EPOCH)
return simpleflake(**kwargs)
def charge():
"""
Charge URI is the endpoint for charging and sending of sms
This endpoint expects the ff params:
- shortcode
- subscriber_number
- amount
"""
shortcode = request.json['shortcode']
merchant = db.hgetall(shortcode)
if not merchant:
abort(404)
subscriber_number = request.json['subscriber_number']
item_id = request.json.get('item_id', 'demo')
amount = request.json['amount']
# Get the access token from DB
access_token = db.hget(
'{}:{}'.format(shortcode, subscriber_number),
'access_token',
)
if not access_token:
return jsonify(
needs_authorization=True,
dialog_url=const.G_DIALOG.format(merchant['globe_app_id']),
)
sender = shortcode[-4:] # this is weird!
confirm_code = str(
simpleflake())[-6:] # Generate a random code for this user session
params = {'access_token': access_token}
req = {
'outboundSMSMessageRequest': {
'clientCorrelator': str(simpleflake()),
'senderAddress': 'tel:{}'.format(sender),
'outboundSMSTextMessage': {
'message':
'{}\n\nYou will be charged PHP {}. This is your code to proceed: {}'
.format(
merchant['store_name'],
amount,
confirm_code,
),
},
'address': ['tel:+63{}'.format(subscriber_number)],
}
}
res = requests.post(const.G_SMS_ENDPOINT.format(sender),
headers={
'Content-Type': 'application/json',
},
params=params,
data=json.dumps(req))
app.logger.debug(res.content)
if not res.ok:
abort(500)
payload = res.json()
payload.update(confirm_code_sent=True)
# Save confirm code assoc
# Expires after 15 minutes
confirm_key = '{}:{}:confirm:{}'.format(
shortcode,
subscriber_number,
confirm_code,
)
db.hmset(confirm_key, {
'item_id': item_id,
'amount': amount,
})
db.expire(confirm_key, 15 * 60)
return jsonify(**payload)
import random
def my_hash(bits=96):
assert bits % 8 == 0
required_length = bits / 8 * 2
s = hex(random.getrandbits(bits)).lstrip('0x').rstrip('L')
if len(s) < required_length:
return my_hash(bits)
else:
return s
# print my_hash()
# 9c14dac2a6f1d65929095295 # just a sample; it's a string
## or: ##################
# You can also use simpleflake. By default it generates 64 bit
# unique IDs. The generated ID consists of 2 parts: a) timestamp,
# b) random number. It has the advantage that the generated IDs
# arrive in ascending order.
# see http://engineering.custommade.com/simpleflake-distributed-id-generation-for-the-lazy/
$ pip install simpleflake
>>> import simpleflake
>>> simpleflake.simpleflake()
3620361890155888216L # just a sample
>>> hex(simpleflake.simpleflake()).lstrip('0x').rstrip('L')
'349b3dc4a2976240' # just a sample
def getid():
from simpleflake import simpleflake
return simpleflake()
def __init__(self, name: str = "") -> None:
self.id = simpleflake()
self.name = name
def test_simpleflake_size(self):
flake = sf.simpleflake()
self.assertEquals(64, len(sf.binary(flake)))
def __init__(self, group=None, target=None, name=None,
args=(), kwargs=None, verbose=None):
threading.Thread.__init__(self, group=group, target=target, name=name,
verbose=verbose)
self.args = args
self.kwargs = kwargs
self.worker = up.DropboxUploader(self.args)
self.worker.client = dbClient
self.state = -1 #It can be 0 for stop when the next chunk is uploaded
#or 1 for delete the upload.
def run(self):
logging.debug('Starting Upload of the file:{}'.format(self.args))
for i in self.worker.upload_chunked():
logging.debug(i)
if self.state == 0:
return #send signal to UI
elif self.state == 1:
return #delete the thread, dont update the ui even if
#a chunk is uploaded in the meantime.
self.worker.finish('/new.pdf') #change path
logging.debug('Upload completed.') #write to history with global lock
#raise event to inform user
return
paths = [r"C:\Users\Fadi\Desktop\03.Colloquial Swedish 2007.pdf"]
t = MyThreadWithArgs(name=str(simpleflake()), args=paths[0])
t.start()
def get_uuid():
return str(simpleflake())
target=target,
name=name,
verbose=verbose)
self.args = args
self.kwargs = kwargs
self.worker = up.DropboxUploader(self.args)
self.worker.client = dbClient
self.state = -1 #It can be 0 for stop when the next chunk is uploaded
#or 1 for delete the upload.
def run(self):
logging.debug('Starting Upload of the file:{}'.format(self.args))
for i in self.worker.upload_chunked():
logging.debug(i)
if self.state == 0:
return #send signal to UI
elif self.state == 1:
return #delete the thread, dont update the ui even if
#a chunk is uploaded in the meantime.
self.worker.finish('/new.pdf') #change path
logging.debug('Upload completed.') #write to history with global lock
#raise event to inform user
return
paths = [r"C:\Users\Fadi\Desktop\03.Colloquial Swedish 2007.pdf"]
t = MyThreadWithArgs(name=str(simpleflake()), args=paths[0])
t.start()
import random
def my_hash(bits=96):
assert bits % 8 == 0
required_length = bits / 8 * 2
s = hex(random.getrandbits(bits)).lstrip('0x').rstrip('L')
if len(s) < required_length:
return my_hash(bits)
else:
return s
# print my_hash()
# 9c14dac2a6f1d65929095295 # just a sample; it's a string
## or: ##################
# You can also use simpleflake. By default it generates 64 bit
# unique IDs. The generated ID consists of 2 parts: a) timestamp,
# b) random number. It has the advantage that the generated IDs
# arrive in ascending order.
# see http://engineering.custommade.com/simpleflake-distributed-id-generation-for-the-lazy/
$ pip install simpleflake
>>> import simpleflake
>>> simpleflake.simpleflake()
3620361890155888216L # just a sample
