class raitings_by_shop_id(Model): __keyspace__="shop_raitings" store_id = columns.SmallInt(primary_key=True) product_name = columns.Text(primary_key=True) ts = columns.DateTime() price = columns.Float() raiting = columns.SmallInt()
class Response(UserType): """ Response type """ content_type = columns.Text() content_body = columns.Text() status_code = columns.SmallInt() headers = columns.Text() response_on = columns.DateTime() @classmethod def validate_response(cls, response): try: r = cls() if hasattr(response, 'content_type'): r.content_type = response.content_type if hasattr(response, 'data'): r.content_body = response.data if hasattr(response, 'status_code'): r.status_code = response.status_code if hasattr(response, 'headers'): r.headers = json.dumps(response.headers.items(), cls=HttpHeadersEncoder) r.response_on = datetime.utcnow() return r except Exception as e: logger.error('Log response error: %s' % e)
class sparkServerModel(DjangoCassandraModel): serverid = columns.Integer(primary_key=True, default=uuid.uuid4) address = columns.Text() port = columns.SmallInt() def generate_address(self): return "spark://" + self.address + ":" + str(self.port)
class FeedEntryModel(DjangoCassandraModel): class Meta: get_pk_field = 'id' userid = columns.UUID(primary_key=True) id = columns.TimeUUID(primary_key=True, default=timeuuid_now, clustering_order="DESC") comment_count = columns.SmallInt(default=0) @property def published(self): return datetime_from_uuid1(self.id)
class SeismicEvent(DjangoCassandraModel): id = columns.UUID(primary_key=True, default=uuid.uuid4) mag = columns.Double() place = columns.Text() time = columns.DateTime() updated = columns.DateTime() tz = columns.SmallInt() status = columns.Text() tsunami = columns.TinyInt() sig = columns.SmallInt() net = columns.Text() code = columns.Text() ids = columns.Text() sources = columns.Text() types = columns.Text() nst = columns.SmallInt() dmin = columns.Double() rms = columns.Double() gap = columns.SmallInt() magType = columns.Text() type = columns.Text() latitude = columns.Double() longitude = columns.Double() depth = columns.Double()
class Match(Base): id = columns.UUID(primary_key=True, default=uuid.uuid4) date = columns.Text() venue = columns.Text() tournament = columns.Text() competitor_1 = columns.Map(columns.Text(), columns.Integer()) competitor_2 = columns.Map(columns.Text(), columns.Integer()) result = columns.SmallInt() def get_data(self): return { 'id': str(self.id), 'date': self.date, 'venue': self.venue, 'tournament': self.tournament, 'competitor_1': self.competitor_1, 'competitor_2': self.competitor_2, 'result': self.result }
class tweepyServerModel(DjangoCassandraModel): serverid = columns.Integer(primary_key=True, default=uuid.uuid4) address = columns.Text() port = columns.SmallInt() def writeInstructs(self, sentimentId, mode, keywords): import sys sys.path.append('/Users/melihozkan/Desktop/Projects/BitirmeProjesi/') from utils.InstructManager import InstructManager im = InstructManager() return im.writeInstructions(sentimentId, mode, keywords, True) def writeStopFile(self, sentimentId): import sys sys.path.append('/Users/melihozkan/Desktop/Projects/BitirmeProjesi/') from utils.hdfsClient import client tmp = client() tmp.overwrite(path="/tweepy/" + str(sentimentId) + "_stop.txt", data="test") def generate_address(self): return self.address + ":" + str(self.port)
class Allv4Datatypes(UserType): a = columns.Date() b = columns.SmallInt() c = columns.Time() d = columns.TinyInt()
class Transfer(AbstractBaseModel, TaskQueueMixin, MachineMixin): """ Transfer """ __table_name__ = 'transfer' id = columns.UUID(primary_key=True, default=uuid.uuid4) description = columns.Text() value = columns.UserDefinedType(Amount, required=True) account_id = columns.UUID(required=True) destination_id = columns.UUID(required=True) # signatures signatures = columns.Map(columns.Text, columns.Text) # type = columns.Text(discriminator_column=True) status = columns.TinyInt(default=TRANSFER_CREATED[0]) # reverse reversed = columns.Boolean(default=False) value_reversed = columns.UserDefinedType(Amount) # failure failure_code = columns.SmallInt() # cancellation data cancellation_data = columns.UserDefinedType(Cancellation) # tasks tasks = columns.Map(columns.Text, columns.Text) def __init__(self, *args, **kwargs): super(Transfer, self).__init__(*args, **kwargs) self._init_machine() # --------------- # Machine Methods # --------------- def _init_machine(self): """ Method to hook a state machine to the instance """ states = list(TRANSFER_STATUS_STRING_CHOICES) transitions = TRANSFER_STATE_TRANSITIONS self.machine = Machine(model=self, states=states, transitions=transitions, auto_transitions=False, send_event=True, initial=TRANSFER_STATUS_MAP[self.status], after_state_change='_state_changed') def _state_changed(self, event): """ callback from state machine to change status on instance and persist :param event: EventData :return: """ self.status = TRANSFER_STATUS_STRING_MAP[event.state.name] persist = event.kwargs.get('persist', False) if persist: self.save() def _is_txn_valid(self, txn=None): return txn is not None and self.id == txn.source_id def _get_act_txn(self, event): act_txn = event.kwargs.get('act_txn') if self._is_txn_valid(act_txn): return act_txn act_txn = DebitAccountTransaction.objects.filter(account_id=self.account_id).get() if self._is_txn_valid(act_txn): return act_txn if act_txn is None: raise AccountTransactionNotAvailable def _get_dst_txn(self, event): dst_txn = event.kwargs.get('dst_txn') if self._is_txn_valid(dst_txn): return dst_txn dst_txn = CreditAccountTransaction.objects.filter(account_id=self.destination_id).get() if self._is_txn_valid(dst_txn): return dst_txn if dst_txn is None: raise DestinationTransactionNotAvailable def set_account_signature(self, event, **kwargs): """ :param args: :param kwargs: :return: """ act_signature = event.kwargs.get('act_signature') # TODO is signature valid if act_signature: self.signatures['act_signature'] = act_signature def set_destination_signature(self, event, **kwargs): """ :param args: :param kwargs: :return: """ dst_signature = event.kwargs.get('dst_signature') # TODO is signature valid if dst_signature: self.signatures['dst_signature'] = dst_signature def has_valid_account_signature(self, event, **kwargs): """ :param args: :param kwargs: :return: """ signature = self.signatures.get('act_signature') # TODO is signature valid if signature is not 'signature': self.failure_code = FAILURE_INVALID_ACCOUNT_SIGNATURE[0] return False return True def has_valid_destination_signature(self, event, **kwargs): """ :param args: :param kwargs: :return: """ signature = self.signatures.get('dst_signature') # TODO is signature valid if signature is not 'signature': self.failure_code = FAILURE_INVALID_DESTINATION_SIGNATURE[0] return False return True def has_transaction_account_succeed(self, event, **kwargs): """ :param args: :param kwargs: :return: """ act_txn = self._get_act_txn(event) if act_txn.is_succeed(): return True if act_txn.is_failed(): self.failure_code = FAILURE_INVALID_ACCOUNT_OPERATION_ERROR[0] return False def has_transaction_destination_succeed(self, event, **kwargs): """ :param args: :param kwargs: :return: """ dst_txn = self._get_dst_txn(event) if dst_txn.is_succeed(): return True if dst_txn.is_failed(): self.failure_code = FAILURE_INVALID_ACCOUNT_OPERATION_ERROR[0] return False def has_failure_code(self, event, **kwargs): """ :param args: :param kwargs: :return: """ return self.failure_code is not None def set_cancellation_data(self, event, **kwargs): """ :param args: :param kwargs: :return: """ reason = event.kwargs.get('reason') if reason is None: raise ReasonNotAvailable user = event.kwargs.get('user') if user is not None: self.cancellation_data = Cancellation(reason=reason, user=CancellationByUser(id=user.id)) return queue_name = event.kwargs.get('queue_name') task_name = event.kwargs.get('task_name') if queue_name is not None and task_name is not None: task = CancellationByTask(name=task_name, queue_name=queue_name) cancellation = Cancellation(reason=reason, task=task) self.cancellation_data = cancellation def has_cancellation_data(self, event, **kwargs): """ :param args: :param kwargs: :return: """ return self.cancellation_data.type is not None def execute_cancel(self, event, **kwargs): """ :param args: :param kwargs: :return: """ if self.has_cancellation_data(event): persist = event.kwargs.get('persist', False) # act_txn = self._get_act_txn(event) act_txn = self._cancel_txn(act_txn, persist) event.kwargs.update({'act_txn': act_txn}) # dst_txn = self._get_dst_txn(event) dst_txn = self._cancel_txn(dst_txn, persist) event.kwargs.update({'dst_txn': dst_txn}) def remove_expired_task(self, event, **kwargs): """ :param args: :param kwargs: :return: """ task_name = self.tasks.get('cancel') if task_name: queue_name = self.__table_name__ self.remove_task(queue_name=queue_name, name=task_name) del self.tasks['cancel'] # --------------- # Task Methods # --------------- def create_expired_task(self): kwargs = dict() action = 'cancel' url_params = {'id': self.id, 'action': action} url = url_for('tasks.transfer_actions', **url_params) kwargs['queue_name'] = self.__table_name__ kwargs['method'] = 'PUT' kwargs['url'] = url kwargs['eta'] = datetime.utcnow() + timedelta(hours=24) kwargs['payload'] = urllib.urlencode({'action': action, 'metadata': json.dumps({'reason': 'expired'})}) # context['target'] = modules.get_current_module_name() task = self.add_task(**kwargs) if isinstance(task, taskqueue.Task): self.tasks['cancel'] = task.name
class AccountTransaction(AbstractBaseModel): """ AccountTransaction """ __table_name__ = 'account_transaction' account_id = columns.UUID(primary_key=True) id = columns.TimeUUID(primary_key=True, clustering_order='DESC', default=uuid.uuid1) description = columns.Text() value = columns.UserDefinedType(Amount) source_id = columns.UUID() signature = columns.Text() type = columns.Text(discriminator_column=True) status = columns.TinyInt(default=TRANSACTION_PENDING[0], index=True) # failure code failure_code = columns.SmallInt() def __init__(self, *args, **kwargs): super(AccountTransaction, self).__init__(*args, **kwargs) self._init_machine() # --------------- # Machine Methods # --------------- def _init_machine(self, transitions=TRANSACTION_STATE_TRANSITIONS): """ Method to hook a state machine to the instance """ states = list(TRANSACTION_STATUS_STRING_CHOICES) self.machine = Machine(model=self, states=states, transitions=transitions, auto_transitions=False, send_event=True, initial=TRANSACTION_STATUS_MAP[self.status], after_state_change='_state_changed') def _state_changed(self, event): """ callback from state machine to change status on instance and persist :param event: EventData :return: """ self.status = TRANSACTION_STATUS_STRING_MAP[event.state.name] persist = event.kwargs.get('persist', False) if persist: self.save() def execute_operation(self, event, **kwargs): """ :param event: EventData :return: """ transfer = event.kwargs.get('transfer') if transfer is None: raise TransferNotAvailable if transfer.is_sealed(): account = CurrentAccount.objects(id=self.account_id).get() response = account.execute_pending(self.id) event.kwargs.update({'operation_response': response}) account.save() else: event.kwargs.update({ 'operation_response': Response(error=FAILURE_TRANSFER_IS_NOT_SEALED) }) def execute_cancel(self, event, **kwargs): """ :param event: EventData :return: """ transfer = event.kwargs.get('transfer') if transfer is None: raise TransferNotAvailable if transfer.is_created(): account = CurrentAccount.objects(id=self.account_id).get() response = account.cancel_pending(self.id) event.kwargs.update({'operation_response': response}) account.save() def has_execute_succeed(self, event, **kwargs): """ :param event: EventData :return: """ response = event.kwargs.get('operation_response') if not response.is_success: self.failure_code = response.error_code return False return True def has_failure_code(self, event, **kwargs): """ :param event: EventData :return: """ return self.failure_code is not None
class receipts_by_store_id(Model): __keyspace__="shop_receipts" store_id = columns.SmallInt(primary_key=True) topic = columns.Text(primary_key=True) ts = columns.DateTime() value = columns.SmallInt()
class v4DatatypesModel(Model): id = columns.Integer(primary_key=True) a = columns.Date() b = columns.SmallInt() c = columns.Time() d = columns.TinyInt()