Exemplo n.º 1
0
 def delete(self, request, *args, **kw):  # deletes table
     db_id = request.data.get("db_id", None)
     table_id = request.data.get("table_id", None)
     access_token = request.META.get("HTTP_ACCESS_TOKEN", None)
     result = {}
     result[RESPONSE_STATUS] = RESPONSE_STATUS_ERROR
     if db_id and ObjectId.is_valid(db_id) and access_token:
         mainDB = getDatabase()
         token = mainDB.tokens.find_one({"token": access_token}) if mainDB else None
         if token and access_token_valid(token):
             if mainDB:
                 result[RESPONSE_STATUS] = RESPONSE_STATUS_SUCCESS
                 if table_id:
                     if ObjectId.is_valid(table_id):
                         result[DELETED_TABLE_COUNT] = mainDB.tables.delete_one(
                             {"_id": ObjectId(table_id), "author": token["author"], "database_id": ObjectId(db_id)}
                         ).deleted_count
                     else:
                         result[RESPONSE_STATUS] = RESPONSE_STATUS_ERROR
                         result[RESPONSE_STATUS_ERROR_MSG] = TABLE_ID_INVALID
                 else:
                     result[DELETED_TABLE_COUNT] = mainDB.tables.delete_many(
                         {"author": token["author"], "database_id": ObjectId(db_id)}
                     ).deleted_count
             else:
                 result[RESPONSE_STATUS_ERROR_MSG] = MASTER_DB_UNINITIALIZED
         else:
             result[RESPONSE_STATUS_ERROR_MSG] = ACCESS_TOKEN_INVALID
     else:
         result[RESPONSE_STATUS_ERROR_MSG] = TOKEN_MISSING if not access_token else DATABASE_ID_INVALID
     response = Response(result, status=status.HTTP_200_OK)
     return response
Exemplo n.º 2
0
    def _updateStartingPanelID(self, comicID, firstPanelID):
        """This is a private method.
           Add the firstPanelID to the given comic as the starting panel,
           return true if successful, false otherwise"""
        if (not ObjectId.is_valid(comicID)) or (not ObjectId.is_valid(firstPanelID)):
            return False

        if (self.comicsCollection.find_and_modify({self.idField: ObjectId(comicID)}, 
                {"$set" : {self.firstPanelIDField : firstPanelID} }) != None):
            return True
        return False # update unsuccessful
Exemplo n.º 3
0
    def update_mirroring(frame_id, mirroring_id):
        """
        Set a frame to mirror another by id
        """
        fid = frame_id if not ObjectId.is_valid(frame_id) else ObjectId(frame_id)
        mid = frame_id if not ObjectId.is_valid(mirroring_id) else ObjectId(mirroring_id)

        doc = {"mirroring": mid}

        resp = Frames.collection.find_one_and_update({"_id": fid}, {"$set": doc}, return_document=ReturnDocument.AFTER)

        return _unify_ids(resp)
    def test_is_valid(self):
        self.assertFalse(ObjectId.is_valid(None))
        self.assertFalse(ObjectId.is_valid(4))
        self.assertFalse(ObjectId.is_valid(175.0))
        self.assertFalse(ObjectId.is_valid({"test": 4}))
        self.assertFalse(ObjectId.is_valid(["something"]))
        self.assertFalse(ObjectId.is_valid(""))
        self.assertFalse(ObjectId.is_valid("12345678901"))
        self.assertFalse(ObjectId.is_valid("1234567890123"))

        self.assertTrue(ObjectId.is_valid(b("123456789012")))
        self.assertTrue(ObjectId.is_valid("123456789012123456789012"))
 def update_artifact_by_id(self,collection,artifact_id,field=None,value=None,document=None):
     if document:
         #Careful, this replaces the document entirely
         if ObjectId.is_valid(artifact_id):
             self.c[collection].update({"_id":ObjectId(artifact_id)}, document)
         else:
             self.c[collection].update({"_id":artifact_id}, document)
     elif field and value:
         if ObjectId.is_valid(artifact_id):
             self.c[collection].update({"_id":ObjectId(artifact_id)}, {"$set" : {field:value}})
         else:
             self.c[collection].update({"_id":artifact_id}, {"$set" : {field:value}})
     else:
         raise WrongParametersExecption
 def add_item_to_artifact_set(self,collection,artifact_id,field,value):
     self.init_artifact_set(collection,artifact_id,field,[])
     if ObjectId.is_valid(artifact_id):
         self.c[collection].update({"_id":ObjectId(artifact_id)},{"$addToSet":{field: value}})
     else:
         self.c[collection].update({"_id":artifact_id},{"$addToSet":{field: value}})
     self.update_artifact_state(collection, artifact_id)
Exemplo n.º 7
0
    def put(self, id):
        """
        Update slide information
        ---
        tags:
          - Slide
        parameters:
          - in: path
            name: id
            description: MonogDB ObjectId -- Example 57bf3c092f9b2e1595b29730
            type: string
          - in: body
            name: json
            description: JSON object containing parameters to update
            type: string
        responses:
          200:
            description: Returns the slide information
          404:
          	description: Invalid slide Id or slide not found
        """

        if not ObjectId.is_valid(id):
            resp = {"status": 404, "message": "Invalid slide Id " + id}
            return Response(dumps(resp), status=404, mimetype="application/json")

        image = self.slides.find_one({"_id": ObjectId(id)}, {"scanProperties": False})

        if image:
            self.slides.update_one({"_id": ObjectId(id)}, {"$set": request.get_json(force=True)})
            image = self.slides.find_one({"_id": ObjectId(id)}, {"scanProperties": False})
            image["id"] = str(image["_id"])
            return Response(dumps(image), status=200, mimetype="application/json")
        else:
            return Response("", status=404, mimetype="application/json")
Exemplo n.º 8
0
    def get(self, entity_id, chart_id):
        if not ObjectId.is_valid(chart_id):
            self.set_status(httplib.BAD_REQUEST)
            raise Return()

        if entity_id not in ICON_ENTITIES:
            self.set_status(httplib.NOT_FOUND)
            raise Return()

        chart = yield Query(self.settings["database"], entity_id.capitalize()).find_one({"_id": ObjectId(chart_id)})
        if chart is None:
            self.set_status(httplib.NOT_FOUND)
            raise Return()

        icon_data, last_updated = self._get_chart_icon(chart)

        modified_since = self.request.headers.get(resources.IF_MODIFIED_HEADER)
        if modified_since is not None and last_updated == modified_since:
            self.set_status(httplib.NOT_MODIFIED)

        accept = self.request.headers.get(resources.ACCEPT_HEADER)
        if accept is not None and accept.lower() == resources.SVG_CONTENT_TYPE:
            icon = icon_data
            content_type = resources.SVG_CONTENT_TYPE
        else:
            icon = cairosvg.svg2png(icon_data)
            content_type = resources.PNG_CONTENT_TYPE

        self.add_header(resources.CONTENT_TYPE_HEADER, content_type)
        self.add_header(resources.CACHE_CONTROL, resources.CACHE_CONTROL_NO_CACHE)

        self.write(icon)
Exemplo n.º 9
0
	def get(self, id):
		"""
        Get deep zoom image
        ---
        tags:
          - Deep Zoom
        parameters:
          - in: path
            name: id
            description: MonogDB ObjectId -- Example 57bf3c092f9b2e1595b29730
            type: string
        responses:
          200:
            description: Returns the slide information
          404:
          	description: Invalid slide Id or slide not found
        """

		if not ObjectId.is_valid(id):
			resp = {"status": 404, "message": "Invalid slide Id " + id}
			return Response(dumps(resp), status=404, mimetype='application/json')

		image = self.slides.find_one({'_id': ObjectId(id)})
		path = image["path"]
		slide = get_slide(path)

		if slide == None:
			Response("", status=404, mimetype='application/xml')
		else:
			return Response(slide.get_dzi(self.config['deepzoom_format']), status=200, mimetype='application/xml')
Exemplo n.º 10
0
 def update_by_id(user_id, doc):
     """
     Update user by id, returning the updated doc
     """
     cid = user_id if not ObjectId.is_valid(user_id) else ObjectId(user_id)
     return Users.collection.find_one_and_update(
         {"_id": cid}, {"$set": doc}, return_document=ReturnDocument.AFTER)
Exemplo n.º 11
0
 def load_document(self, bucket, doc_id):
     if not doc_id:
         raise Exception('Need a doc_id to load a document')
     if ObjectId.is_valid(doc_id):
         doc_id = ObjectId(doc_id)
     handle = self.handle(bucket)
     return handle.find_one(doc_id)
Exemplo n.º 12
0
 def delete_by_id(frame_id):
     """
     Update a frame by id, returning the updated doc
     """
     fid = frame_id if not ObjectId.is_valid(frame_id) else ObjectId(frame_id)
     resp = Frames.collection.delete_one({"_id": fid})
     return _unify_ids(resp)
Exemplo n.º 13
0
def get_email_or_404(id_str):
    if not ObjectId.is_valid(id_str):
        raise ObjectDoesNotExist()
    email = Email.find_one({'_id': ObjectId(id_str)})
    if not email:
        raise ObjectDoesNotExist()
    return email
Exemplo n.º 14
0
def todo_delete(id):
    if ObjectId.is_valid(id):
        result = todos.delete_one({'_id': ObjectId(id)})
        if result.deleted_count > 0:
            return jsonify({'result': 'Successfully removed ' + id})

    return not_found()
Exemplo n.º 15
0
def todo_get(id):
    if ObjectId.is_valid(id):
        todo = todos.find_one({'_id': ObjectId(id)})
        if todo:
            return jsonify(todo)

    return not_found()
Exemplo n.º 16
0
def get_resource_or_404(id_str):
    if not ObjectId.is_valid(id_str):
        raise ObjectDoesNotExist()
    id = ObjectId(id_str)
    if not gfs.exists(id):
        raise ObjectDoesNotExist()
    return gfs.get(id)
Exemplo n.º 17
0
def delData(request,res,db):
    '''
        Desc:
            fetch all data about the user
        Args:
            request: request with different data
            res: result that we need to update and return
        Err:
            1. invalid objectId
            2. fail to delete data
    '''

    # error handler for invalid objectid
    if not ObjectId.is_valid(res["uid"]):
        res["err"]["status"] = 1
        res["err"]["msg"] = "wrong id"
        return res

    data = {"_id":ObjectId(res["uid"])}

    # data = {"sid":{"$in":schedule_list}}
    docs = db.removeData(data)

    # error handler for getting data
    if docs["status"]:
        res["err"] = docs
        return res

    #
    # normal process
    #
    return res
Exemplo n.º 18
0
def delData(request,res,db):
    '''
        Desc:
            delete the schedule exercise by id
        Args:
            request: maybe useful
            res: id stores in res["sid"], and update res with proper information
        Err:
            1. invalid objectId
            2. fail to delete data
    '''

    # error handler for invalid objectid
    if not ObjectId.is_valid(res["sid"]):
        res["err"]["status"] = 1
        res["err"]["msg"] = "wrong id"
        return res

    data = {"_id":ObjectId(res["sid"])}

    # data = {"sid":{"$in":schedule_list}}
    docs = db.removeData(data)

    # error handler for getting data
    if docs["status"]:
        res["err"] = docs
        return res

    #
    # normal process
    #
    res["content"]["status"] = "successful"
    return res
Exemplo n.º 19
0
 def get_by_id(user_id):
     """
     Get user by id
     """
     cid = user_id if not ObjectId.is_valid(user_id) else ObjectId(user_id)
     return Users.collection.find_one({'_id': cid},
                                      projection=Users.default_projection)
Exemplo n.º 20
0
def edit_post(post_id):
    form = PostEditForm(request.form)

    if not ObjectId.is_valid(post_id):
        abort(404)

    post = Post.objects(id=post_id).first()
    if post is None:
        abort(404)

    if not post.can_edit(current_user):
        abort(403)

    topic = post.topic
    board = topic.board
    forum = post.forum

    if request.method == "POST" and form.validate():
        post_edit = PostEdit(author=current_user.to_dbref(), content=form.content.data, date=datetime.utcnow())
        post.edits.append(post_edit)
        post.content = form.content.data
        post.save()

        return redirect(topic.get_url())

    form.content.data = post.content
    return render_template("forum_post_edit.html", form=form, topic=topic, board=board, forum=forum)
Exemplo n.º 21
0
def putData(request,res,db):
    '''
        Desc:
            update some fields of a schedule exercise
        Args:
            request: store the updated information of exercise within request.form
            db: referrence to db object
            res: store the status
        Err:
            1. fail to update data
    '''


    if not ObjectId.is_valid(res["sid"]):
        #res["err"]["status"] = 1
        #res["err"]["msg"] = "wrong id"
        #return res
        match_data = {"sid":int(res["sid"])}
    else:
        match_data = {"_id":ObjectId(res["sid"])}

    docs = db.updateData(match_data,request.form)

    # catch the error of updating
    if docs["status"]:
        res["err"] = docs
        return res

    # return the status
    res["content"]["status"] = docs["status"]

    return res
Exemplo n.º 22
0
	def handleSellMaterial(self, rqst, owner):
		ses = self.sessions.get(owner, None)
		if ses != None:
			try:
				pid = ObjectId(rqst.data['pid'])
				if not ObjectId.is_valid(pid):
					return

				matData = self.database.fetchPlayerItemData(pid)['Material']

				price = 0
				for i in matData:
					for j in rqst.data['mat']:
						if j['type'] == i['type'] and j['level'] == i['level']:
							if j['count'] > i['count']:
								return
							else:
								price += self.getMaterialSetting(j['type'], j['level'])[1] * j['count']
								i['count'] -= j['count']
				# remove whose count is 0:
				rev = range(len(matData))
				rev.reverse()
				for i in rev:
					if matData[i]['count'] == 0:
						del matData[i]

				if price == rqst.data['price']:	
					pprop = self.database.fetchPlayerProperty(pid)
					pprop['Coins'] = pprop['Coins'] + price
					self.database.updatePlayerProperty(pid, pprop)
					self.database.updatePlayerMaterial(pid, matData)

			except:
				print '%d sell material failed'%(owner)
Exemplo n.º 23
0
def approveUser(ID, accept):
    if not ObjectId.is_valid(ID): return False
    if ID == str(session['user']['_id']): return False
    
    result = db.users.update_one({'_id' : ObjectId(ID), 'confirmed' : True,
         'clinic' : session['user']['clinic']}, {'$set' : {'approved' : accept}})
        
    if result.modified_count == 1 or accept == False:
        info = db.users.find_one({'_id' : ObjectId(ID)})
        if not info: return False #cover all of our bases
            
        if accept:
            userMsg = Message('Account Approved', #app title
                sender = ('Example Administrator', '*****@*****.**'),
                recipients = [(info['first'] + ' ' + info['last'], info['email'])])
            userMsg.body = template('finalUser.txt', user = info, accept = True)
            userMsg.html = template('finalUser.html', user = info, accept = True)
            
        else:
            userMsg = Message('Account Removed', #app title
                sender = ('Example Administrator', '*****@*****.**'),
                recipients = [(info['first'] + ' ' + info['last'], info['email'])])
            userMsg.body = template('finalUser.txt', user = info, accept = False)
            userMsg.html = template('finalUser.html', user = info, accept = False)
            
            deletion = db.users.delete_one({'_id' : ObjectId(ID)})
            if deletion.deleted_count == 0: return False
            
        mail.send(userMsg)
        return True
    
    #something messed up
    return False
Exemplo n.º 24
0
def update_menu(menu_id):
    # check if menu_id coming in from URL is a valid ObjectId format
    if ObjectId.is_valid(menu_id):
        menu = mongo.db.menus.find_one_or_404({"_id": ObjectId(menu_id)})
    else:
        abort(404)

    if not request.json:
        abort(400)
    if "menu_name" in request.json and type(request.json["menu_name"]) != unicode:
        abort(400)

    # update using request json variable, if not present use current one in the db.
    mongo.db.menus.update(
        {"_id": ObjectId(menu_id)},
        {
            "$set": {
                "menu_name": request.json.get("menu_name", menu["menu_name"]),
                "URL": request.json.get("URL", menu["URL"]),
                "show_on_nav": request.json.get("show_on_nav", menu["show_on_nav"]),
                "sort_order": request.json.get("sort_order", menu["sort_order"]),
            }
        },
    )

    return jsonify({"update": "success"})
Exemplo n.º 25
0
 def put(self, request, *args, **kw): # updates the database
     db_id = request.GET.get('db_id', None)
     access_token = request.META.get('HTTP_ACCESS_TOKEN', None)
     result = {}
     result[RESPONSE_STATUS] = RESPONSE_STATUS_ERROR
     if db_id and access_token:
         mainDB = getDatabase()
         token = mainDB.tokens.find_one({"token": access_token}) if mainDB else None
         if token and access_token_valid(token):
             if ObjectId.is_valid(db_id):
                 database = mainDB.databases.find_one({"author": token["author"], "_id": ObjectId(db_id)})
                 if database:
                     db_name = request.GET.get('db_name', None) or database["database_name"]
                     db_name = ''.join(db_name.split(' ')).lower()
                     mainDB.databases.update_one(
                         {"_id": ObjectId(db_id), "author": token["author"]}, 
                         {
                             "$set": {
                                 "database_name": db_name,
                             }
                         }
                     )
                     result[RESPONSE_STATUS] = RESPONSE_STATUS_SUCCESS
                     result[RESPONSE_STATUS_SUCCESS_MSG] = DATABASE_UPDATED.format(db_name)
                     result[DATABASE_ID] = db_id
                 else:
                     result[RESPONSE_STATUS_ERROR_MSG] = DATABASE_NOT_FOUND
             else:
                 result[RESPONSE_STATUS_ERROR_MSG] = DATABASE_ID_INVALID
         else:
             result[RESPONSE_STATUS_ERROR_MSG] = ACCESS_TOKEN_INVALID
     else:
         result[RESPONSE_STATUS_ERROR_MSG] = TOKEN_MISSING if not access_token else DATABASE_ID_INVALID
     response = Response(result, status=status.HTTP_200_OK)
     return response
Exemplo n.º 26
0
 def get(self, request, *args, **kw): # get database details
     db_id = request.GET.get('db_id', None)
     access_token = request.META.get('HTTP_ACCESS_TOKEN', None)
     result = {}
     result[RESPONSE_STATUS] = RESPONSE_STATUS_ERROR
     if access_token:
         mainDB = getDatabase()
         token = mainDB.tokens.find_one({"token": access_token}) if mainDB else None
         if token and access_token_valid(token):
             if mainDB:
                 result[RESPONSE_STATUS] = RESPONSE_STATUS_SUCCESS
                 if db_id:
                     if ObjectId.is_valid(db_id):
                         result[DATABASE_KEY] = dumps(mainDB.databases.find_one({"_id": ObjectId(db_id), "author": token['author']}))
                     else:
                         result[RESPONSE_STATUS] = RESPONSE_STATUS_ERROR
                         result[RESPONSE_STATUS_ERROR_MSG] = DATABASE_ID_INVALID
                 else:
                     result[DATABASE_KEY] = dumps(mainDB.databases.find({"author": token['author']}))
             else:
                 result[RESPONSE_STATUS_ERROR_MSG] = MASTER_DB_UNINITIALIZED
         else:
             result[RESPONSE_STATUS_ERROR_MSG] = ACCESS_TOKEN_INVALID
     else:
         result[RESPONSE_STATUS_ERROR_MSG] = TOKEN_MISSING
     response = Response(result, status=status.HTTP_200_OK)
     return response
Exemplo n.º 27
0
def getClinicName(ID):
    if not ObjectId.is_valid(ID): return None
    #do we want a more human-readable clinic code in the future?
    #this is good because we don't need to f**k with autoincrement
    clinic = db.clinics.find_one({'_id' : ObjectId(ID)})
    if clinic: return clinic['name']
    return None
Exemplo n.º 28
0
    def _search(self, query, search_term):
        # TODO: Unfortunately, MongoEngine contains bug which
        # prevents running complex Q queries and, as a result,
        # Flask-Admin does not support per-word searching like
        # in other backends
        op, term = parse_like_term(search_term)

        criteria = None

        for field in self._search_fields:
            flt = {}
            if isinstance(field, (mongoengine.base.fields.ObjectIdField)):
                if ObjectId.is_valid(term):
                    flt = {field.name: term}
                else:
                    continue
            elif field.name.startswith("_"):
                # Don't process internal fields, such as _cls
                # which will be used in cases of inherited document classes
                continue
            else:
                flt = {'%s__%s' %
                       (field if isinstance(field, string_types) else field.name, op): term}
            q = mongoengine.Q(**flt)

            if criteria is None:
                criteria = q
            else:
                criteria |= q

        return query.filter(criteria)
def edit_book(book_id):
    """ Checks if user is signed in and is admin, then render editbook.html """
    if ObjectId.is_valid(book_id):
        the_book = mongo.db.books.find_one({"_id": ObjectId(book_id)})
        if 'username' in session and session['username'] == 'admin':
            return render_template('editbook.html', book=the_book)
        return render_template('sorry.html')
    return render_template('nosuchbook.html')
Exemplo n.º 30
0
def extract_creation_date(document, primary_key):
    if primary_key in document:
        objectId = document[primary_key]

        if ObjectId.is_valid(objectId):
            return ObjectId(objectId).generation_time

    return None
Exemplo n.º 31
0
async def read_one(movie_id: str):
    collection = get_collection("movies")
    if ObjectId.is_valid(movie_id):
        found = await collection.find_one({"_id": ObjectId(movie_id)})
        if found:
            return found
    # raise HTTPException(status_code=404, detail="Not found.")  # It's OK
    return JSONResponse({"error": "NOT FOUND"}, status_code=404)
Exemplo n.º 32
0
    def toObjectId(value):
        """
        if value is valid string convert it to ObjectId else leave unchanged
        """
        if isinstance(value, str) and ObjectId.is_valid(value):
            return ObjectId(value)

        return value
Exemplo n.º 33
0
    def validate(cls, v):
        if not ObjectId.is_valid(v):
            raise ValueError('Invalid objectid')
        return ObjectId(v)

    # @classmethod
    # def __modify_schema__(cls, field_schema):
    #     field_schema.update(type='string')
def get_menu(menu_id):
    #check if menu_id coming in from URL is a valid ObjectId format
    if (ObjectId.is_valid(menu_id)):
        menu = mongo.db.menus.find_one_or_404({'_id': ObjectId(menu_id)})
    else:
        abort(404)

    return mongo_to_jsonResponse(menu)
def delete_book(book_id):
    """ Checks if user is signed in and is admin, then deletes a book """
    if ObjectId.is_valid(book_id):
        if 'username' in session and session['username'] == 'admin':
            mongo.db.books.delete_one({'_id': ObjectId(book_id)})
            return redirect(url_for('allbooks'))
        return render_template('sorry.html')
    return render_template('nosuchbook.html')
def delete_menu(menu_id):
    #check if menu_id coming in from URL is a valid ObjectId format
    if (ObjectId.is_valid(menu_id)):
        mongo.db.menus.find_one_or_404({'_id': ObjectId(menu_id)})
    else:
        abort(404)
    mongo.db.menus.remove({'_id': ObjectId(menu_id)})
    return jsonify({'delete': 'success'})
Exemplo n.º 37
0
def get_contact(id):
    if not ObjectId.is_valid(id):
        return {"message": "Invalid ID"}
    contact = {"_id": ObjectId(id)}
    find = col.find_one(contact)
    if find is None:
        return {"error": "contact not found"}
    return {'_id': str(contact['_id']), 'name': find['name'], 'number': find['number'], 'email': find['email']}
Exemplo n.º 38
0
def extract_creation_date(document, primary_key):
    if primary_key in document:
        objectId = document[primary_key]

        if ObjectId.is_valid(objectId):
            return ObjectId(objectId).generation_time

    return None
Exemplo n.º 39
0
def get_place(placeId):
    if not ObjectId.is_valid(photoId):
        raise BadRequest('Invalid id value.')  
    
    objectId = ObjectId(placeId)   
    place = places_collection.find_one({'_id' : objectId})
    place['_id'] = str(place['_id'])
    return json.dumps({'place' : place}, indent = 4, ensure_ascii = False)
Exemplo n.º 40
0
def class_from_id(type_, _id):
    """
    Return an instantiated class object.

    :param type_: The CRIPTs top-level object type.
    :type type_: str
    :param _id: The ObjectId to search for.
    :type _id: str
    :returns: class which inherits from
              :class:`cripts.core.cripts_mongoengine.CriptsBaseAttributes`
    """

    #Quick fail
    if not _id or not type_:
        return None

    # doing this to avoid circular imports
    from cripts.comments.comment import Comment
    from cripts.core.cripts_mongoengine import Action
    from cripts.core.source_access import SourceAccess
    from cripts.core.user_role import UserRole
    from cripts.events.event import Event
    from cripts.usernames.username import UserName
    from cripts.targets.target import Target
    from cripts.hashes.hash import Hash
    from cripts.datasets.dataset import Dataset
    from cripts.email_addresses.email_address import EmailAddress

    # make sure it's a string
    _id = str(_id)

    # Use bson.ObjectId to make sure this is a valid ObjectId, otherwise
    # the queries below will raise a ValidationError exception.
    if not ObjectId.is_valid(_id.decode('utf8')):
        return None

    if type_ == 'Comment':
        return Comment.objects(id=_id).first()
    elif type_ == 'Event':
        return Event.objects(id=_id).first()
    elif type_ == 'Action':
        return Action.objects(id=_id).first()
    elif type_ == 'SourceAccess':
        return SourceAccess.objects(id=_id).first()
    elif type_ == 'UserRole':
        return UserRole.objects(id=_id).first()
    elif type_ == 'UserName':
        return UserName.objects(id=_id).first()
    elif type_ == 'Target':
        return Target.objects(id=_id).first()
    elif type_ == 'Hash':
        return Hash.objects(id=_id).first()
    elif type_ == 'Dataset':
        return Dataset.objects(id=_id).first()
    elif type_ == 'EmailAddress':
        return EmailAddress.objects(id=_id).first()
    else:
        return None
Exemplo n.º 41
0
    def mutate(self, root, fields):
        if ObjectId.is_valid(fields['bot_message']['recipient_id']) is True:
            fields['bot_message']['recipient_id'] = ObjectId(
                fields['bot_message']['recipient_id'])

        if ObjectId.is_valid(fields['bot_message']['sender']) is True:
            fields['bot_message']['sender'] = ObjectId(
                fields['bot_message']['recipient_id'])

        for message in fields['messages']:
            if ObjectId.is_valid(message['recipient_id']) is True:
                message['recipient_id'] = ObjectId(message['recipient_id'])

            if ObjectId.is_valid(message['sender']) is True:
                message['recipient_id'] = ObjectId(message['sender'])

        fields['user_id'] = ObjectId(get_jwt_identity())
        fields['created_at'] = datetime.datetime.now()

        result = mongo.db.chatbot_feedbacks.insert_one(dict(fields))
        if result.inserted_id is None:
            return CreateChatbotFeedback(
                created_feedback=None,
                response=ResponseMessage(
                    text='Umpan balik pesan chatbot berhasil dikirim',
                    status=True))

        created_feedback = mongo.db.chatbot_feedbacks.find_one({
            '_id':
            result.inserted_id,
            'user_id':
            ObjectId(get_jwt_identity())
        })
        created_feedback['user'] = mongo.db.users.find_one(
            {'_id': ObjectId(get_jwt_identity())})
        created_feedback['created_at'] = {
            'date': created_feedback['created_at'].date(),
            'time': created_feedback['created_at'].time()
        }

        return CreateChatbotFeedback(
            created_feedback=created_feedback,
            response=ResponseMessage(
                text='Umpan balik pesan chatbot berhasil dikirim',
                status=True))
Exemplo n.º 42
0
def todo_update(id):
    content = request.get_json(force=True)
    content['modificationDate'] = int(time())
    if ObjectId.is_valid(id):
        result = todos.update_one({'_id': ObjectId(id)}, {'$set': content})
        if result.modified_count > 0:
            return jsonify({'result': 'Updated ' + id})

    return not_found()
Exemplo n.º 43
0
    def __init__(self, oid=None):
        if not ObjectId.is_valid(oid):
            print("The user ID '%s' is not a valid Object ID." % (oid))
            sys.exit(1)
        self._id = ObjectId(oid)
        self.User = users.User(_id=self._id)
        self.login = self.User.user['login']

        print("\n Working with user \x1b[1;33;40m %s \x1b[0m [%s]" % (self.login, self._id))
Exemplo n.º 44
0
def retrieve_job_activity(object_id):
    """Returns a single job post or none if not found"""
    activities = MongoConnection.get_activities_client()
    if not ObjectId.is_valid(object_id):
        return None
    activity = activities.find_one({"_id": ObjectId(object_id)})
    if activity is not None:
        activity["_id"] = str(activity["_id"])
    return activity
Exemplo n.º 45
0
def get_tag(entry_id):
    if not ObjectId.is_valid(entry_id):
        return APIResponse.bad_request('invalid entry id')

    tag = DB().tag.find_one({'_id': ObjectId(entry_id)})
    if not tag:
        return APIResponse.not_found()

    return APIResponse.ok({'entry': tag})
Exemplo n.º 46
0
    def get_module_version(version_id):
        if not ObjectId.is_valid(version_id):
            raise ModuleVersionInvalidId()

        module_version = instance.find_one(
            ModVersionsConst.COLLECTION_NAME,
            {ModVersionsConst.FIELD_ID: ObjectId(version_id)})
        MongodbFactory.validate_module_version_params(module_version)
        return module_version
Exemplo n.º 47
0
 def get_by_id(user_id):
     u = None
     if ObjectId.is_valid(user_id): #chequea si un string OID es válido, tiene la notación de MongoDB      
         u = db['user'].find_one({ "_id": ObjectId(user_id)})        
     if u is not None:            
         user = User(u['name'], u['email'], u['is_admin'])
         user.password = u['password']
         user.id = u['_id']            
         return user
Exemplo n.º 48
0
    async def remove_item(self, _id) -> Tuple[bool, str]:
        if not ObjectId.is_valid(_id):
            return False, 'invalid_id'

        _id = ObjectId(_id)
        result = await self.collection.delete_one({'_id': _id})
        if result.deleted_count == 1:
            return True, 'removed'
        return False, 'failed'
Exemplo n.º 49
0
def delete_poll(poll_id):
    user_id = ObjectId(get_jwt_identity())

    if not ObjectId.is_valid(poll_id):
        return return_error("Invalid ID format!")

    db.polls.delete_one({"_id": ObjectId(poll_id), "_user_id": str(user_id)})

    return return_json(""), 204
Exemplo n.º 50
0
def add_event_user(db, event_id, user):
    try:
        if ObjectId.is_valid(event_id):
            db.Events.update_one({"_id": ObjectId(event_id)},
                                 {"$push": {
                                     "users": user
                                 }})
    except Exception as e:
        print(e)
    def get_document_comments(self, document_id: str) -> Optional[List]:
        if not ObjectId.is_valid(document_id):
            return None

        comments = list(self.db.comments.find({"document_id": document_id}))
        for comment in comments:
            comment["_id"] = str(comment["_id"])

        return comments
Exemplo n.º 52
0
async def get(db: DBClient, ref: str):
    logging.info(">>> " + __name__ + ":" + get.__name__)
    collection = utils.get_collection(db, config.DOCTYPE_USER)
    if ObjectId.is_valid(ref):
        logging.info("objectid")
        return await utils.get(collection, ref)
    elif ("@" in ref) and ("." in ref):
        return await utils.get(collection, ref, "email")
    return await utils.get(collection, ref, "username")
Exemplo n.º 53
0
def verifyAccessToken(access_token):
    if not ObjectId.is_valid(access_token):
        return 'Invalid access token', False

    token = tokens.find_one({'_id': ObjectId(access_token)})
    if token is None:
        return 'Invalid access token', False

    return None, True
    def delete(self, getid=None):
        '''
        DELETE - /deletedocuments/<getid>
        '''
        client_id = request.headers.get('x-client')
        id_valid = None
        resp_code = None

        # Checks if database is available or not
        if check_database() is not True:
            logger.debug('DB connection error')
            traceback.print_stack(limit=1)
            results = {'message': 'Server is not available'}
            resp_code = ResponseValues.FAILURE.value
            return results, resp_code

        #Checks if valid id provided
        if getid and ObjectId.is_valid(getid):
            id_valid = True
        else:
            logger.debug('Correct Id is not provided for delete operation')
            traceback.print_stack(limit=1)
            results = {'message': 'Server is not available'}
            resp_code = ResponseValues.FAILURE.value
            return results, resp_code

        if client_id is None:
            logger.debug('Client_id not found')
            traceback.print_stack(limit=1)
            results = {'message': 'Client_id not found'}
            resp_code = ResponseValues.FAILURE.value
            return results, resp_code

        if check_collection(client_id) is not None:
            collection_name = check_collection(client_id)
        else:
            logger.debug('No Collection of name ' + str(client_id) +
                         ' is present')
            traceback.print_stack(limit=1)
            results = {'message': 'Server is not available'}
            resp_code = ResponseValues.FAILURE.value
            return results, resp_code

        if id_valid and collection_name.find({
                "_id": ObjectId(getid)
        }).count() != 0:
            collection_name.remove({"_id": ObjectId(getid)})
            logger.info('data deleted successfully for ' + getid)
            results = {'message': 'data deleted successfully for ' + getid}
            resp_code = ResponseValues.SUCCESS.value
        else:
            logger.info('No document present for ' + getid)
            traceback.print_stack(limit=1)
            results = {'message': 'Server is not available'}
            resp_code = ResponseValues.FAILURE.value
        return results, resp_code
Exemplo n.º 55
0
async def read_by_project(id: str,
                          limit: int = 50,
                          skip: int = 0,
                          db: DBClient = client):
    logging.info(f">>> {__name__}:{read_by_project.__name__}")
    if not ObjectId.is_valid(id):
        return utils.create_422_response("Invalid ObjectId")
    evidences = await crud.get_by_project(db, id, limit, skip)
    return utils.create_aliased_response(
        ManyGPQEvidencesResponse(response=evidences, count=len(evidences)))
Exemplo n.º 56
0
def getUserCredentialsById(uid):
    if not ObjectId.is_valid(uid):
        return 'Invalid ID', False

    user = users.find_one({'_id': ObjectId(uid)})
    if user is None:
        print("User with id " + uid + "was not found")
        return 'No user found', False

    return user, True
Exemplo n.º 57
0
 def removeJobs(self, jobID='all'):
     if jobID == 'all':
         rst = self.dbMgr.removeJobs()
         self.__writelnLog('Info: {0} job[s] removed'.format(rst))
     else:
         if ObjectId.is_valid(jobID):
             rst = self.dbMgr.removeJobByID(jobID)
             self.__writelnLog('Info: {0} job removed'.format(rst))
         else:
             self.__writelnLog('Error: invalid job ID {0}'.format(jobID))
Exemplo n.º 58
0
 def delete(self, request, *args, **kw):  #deletes table
     db_id = request.data.get('db_id', None)
     table_id = request.data.get('table_id', None)
     access_token = request.META.get('HTTP_ACCESS_TOKEN', None)
     result = {}
     result[RESPONSE_STATUS] = RESPONSE_STATUS_ERROR
     if db_id and ObjectId.is_valid(db_id) and access_token:
         mainDB = getDatabase()
         token = mainDB.tokens.find_one({"token": access_token
                                         }) if mainDB else None
         if token and access_token_valid(token):
             if mainDB:
                 result[RESPONSE_STATUS] = RESPONSE_STATUS_SUCCESS
                 if table_id:
                     if ObjectId.is_valid(table_id):
                         result[
                             DELETED_TABLE_COUNT] = mainDB.tables.delete_one(
                                 {
                                     "_id": ObjectId(table_id),
                                     "author": token['author'],
                                     "database_id": ObjectId(db_id)
                                 }).deleted_count
                     else:
                         result[RESPONSE_STATUS] = RESPONSE_STATUS_ERROR
                         result[
                             RESPONSE_STATUS_ERROR_MSG] = TABLE_ID_INVALID
                 else:
                     result[
                         DELETED_TABLE_COUNT] = mainDB.tables.delete_many({
                             "author":
                             token['author'],
                             "database_id":
                             ObjectId(db_id)
                         }).deleted_count
             else:
                 result[RESPONSE_STATUS_ERROR_MSG] = MASTER_DB_UNINITIALIZED
         else:
             result[RESPONSE_STATUS_ERROR_MSG] = ACCESS_TOKEN_INVALID
     else:
         result[
             RESPONSE_STATUS_ERROR_MSG] = TOKEN_MISSING if not access_token else DATABASE_ID_INVALID
     response = Response(result, status=status.HTTP_200_OK)
     return response
Exemplo n.º 59
0
def get_user_event_details(oid):
  try:
    if ObjectId.is_valid(oid):
      host_data = audit_collection.find_one({"_id": ObjectId(oid)})
    else:
      host_data = audit_collection.find_one({"_id": ast.literal_eval(oid)})
    formatted = dumps(host_data, indent=2)
    return render_template('user_event_details_data.html', data=formatted, dtg=host_data['ts'])
  except OperationFailure as e:
    print(e.details)
Exemplo n.º 60
0
    def update_module_last_modify(id):
        if not ObjectId.is_valid(id):
            raise ModuleInvalidId()

        return instance.update_one(ModuleConst.COLLECTION_NAME, {
            ModuleConst.FIELD_ID: ObjectId(id)
        }, {'$set': {
            ModuleConst.FIELD_UPDATE_AT: datetime.datetime.utcnow()
        }},
                                   upsert=False)