Esempio n. 1
0
def HandlePostStoryRequest(request):
    if request.method == 'POST':
        authorValue = Author.objects.get(username=request.user)
        received_json_data = json.loads(request.body.decode("utf-8"))
        if request.user.is_authenticated:
            if (received_json_data.get('category')
                    in ['tech', 'pol', 'art', 'trivia']):
                if (received_json_data.get('region') in ['uk', 'w', 'eu']):
                    row = Story(headline=received_json_data.get('headline'),
                                category=received_json_data.get('category'),
                                auth=authorValue,
                                details=received_json_data.get('details'),
                                region=received_json_data.get('region'))
                    row.save()
                    return HttpResponse("CREATED",
                                        status=201,
                                        content_type='text/plain')
                else:
                    return HttpResponse("The region value is invalid",
                                        status=503,
                                        content_type='text/plain')
            else:
                return HttpResponse("The category value is invalid",
                                    status=503,
                                    content_type='text/plain')
        else:
            return HttpResponse("Not authenticated, unable to post story",
                                status=503,
                                content_type='text/plain')
    else:
        return HttpResponse(status=405, content_type='text/plain')
Esempio n. 2
0
    def get(self, story_uid=None):
        """Get a story or a list of a user's stories"""
        request_args = get_current_request_args()

        user_uid = request_args.get('user_uid')

        if user_uid is not None:
            user = User.get_active(uid=user_uid)
            if user is None:
                raise ResourceNotFound('User not found')
        else:
            user = get_current_user()

        if story_uid is not None:
            story = Story.get_active(uid=story_uid, has_expired=False)
            if story is None:
                raise ResourceNotFound('Story not found')

            return api_success_response(data=story.as_json())

        todays_stories = Story.prepare_get_active(user_id=user.id).filter_by(
            has_expired=False).all()

        return api_success_response(
            [story.as_json() for story in todays_stories])
Esempio n. 3
0
def seite_backlog_post():
    data = json.loads(request.form.get("data"))
    story = Story.query.get(data.get("id"))
    sprint_id = data.get("sprint_id", "-1")
    if data.get("to_delete"):
        if story:
            db.session.delete(story)
            db.session.commit()
        return redirect("/backlog")

    if not story:
        story = Story()
        db.session.add(story)

    story.titel = data.get("titel")
    story.beschreibung = data.get("beschreibung")
    story.sprint = Sprint.query.get(sprint_id)

    Kriterium.query.filter_by(story=story).delete()
    for kriterium in data.get("kriterien", []):
        k = Kriterium()
        k.beschreibung = kriterium.get("beschreibung")
        db.session.add(k)
        story.kriterien.append(k)

    db.session.commit()
    return redirect("/backlog")
Esempio n. 4
0
def newstory(request):
    if request.user.is_authenticated():
        elem= {
        'title':'Ny Story',
        }
        if request.method=='POST':
            story_form=StoryForm(request.POST)
            elem.update({'story_form':story_form,})

            if story_form.is_valid():
                print story_form.cleaned_data
                title = request.POST['title']
                length = request.POST['length']
                if request.POST.get('availability'):   
                    availability = request.POST['availability']
                else:
                    availability="Public"
                language=request.POST['language']
                category=request.POST['category']

                newstory=Story(created=datetime.datetime.now(),creator=request.user,title=title,length=length,availability=availability,language=language,category=category)
                newstory.save()
                return HttpResponseRedirect('/home')
            else:
                print "invalid story_form"
        else:
            story_form=StoryForm()
            elem.update({'story_form':story_form,})
        return render_to_response("newstory.html",elem,context_instance=RequestContext(request))
    else:
        return HttpResponseRedirect("/")
Esempio n. 5
0
 def test_uniformity(self):
   p = create_project()
   Story.create(text="As a User, I want to add a user story, so that I document a requirement", project_id=p.id)
   Story.create(text="As a User, I want to add a user story, so that I document another requirement", project_id=p.id)
   story = Story.create(text="As a User, I am able to add a user story, so that I register a requirement", project_id=p.id)
   p.analyze()
   defect = story.defects.filter(Defect.subkind=='uniform')[0]
   assert defect.kind == 'uniform'
   assert defect.severity == 'medium'
Esempio n. 6
0
 def test_identical(self):
   p = create_project()
   story = Story.create(text="As a User, I want to add a user story, so that I document a requirement and sell the system", project_id=p.id)
   story2 = Story.create(text="As a User, I want to add a user story, so that I document a requirement and sell the system", project_id=p.id)
   p.analyze()
   defect1 = story.defects.filter(Defect.subkind=='identical')[0]
   defect2 = story2.defects.filter(Defect.subkind=='identical')[0]
   assert defect1.kind == defect2.kind == 'unique'
   assert defect1.subkind == defect2.subkind == 'identical'
   assert defect1.severity == defect2.severity == 'high'
Esempio n. 7
0
def write_story(request):
    context_dict = {}

    # Check if the request is of type post
    if request.method == 'POST':

        # Get the data in required format
        data = {
            'hospital': Hospital.objects.get(pk=request.user.id),
            'date': request.POST.get("time"),
            'story': request.POST.get("story"),
            'heading': request.POST.get("heading"),
            'likes': 0
        }

        # Handle image import
        if request.FILES.get("file") is not None:
            image = request.FILES["file"]
            fs = FileSystemStorage()
            filename = fs.save(image.name, image)
            uploaded_file_url = filename
            data = {
                'hospital': Hospital.objects.get(pk=request.user.id),
                'date': request.POST.get("time"),
                'story': request.POST.get("story"),
                'heading': request.POST.get("heading"),
                'picture': uploaded_file_url,
                'likes': 0
            }
        # Try to create a new story
        try:
            story = Story()
            story.new_story(data)
            return JsonResponse({
                'success':
                True,
                'message':
                "The review has been succesfully published!"
            })
        except:
            return JsonResponse({
                'success':
                False,
                'message':
                "The provided login details are incorrect!"
            })

    else:
        return redirect("app:app")
Esempio n. 8
0
def write():
    if request.method == 'POST':
        token = request.headers['token']
        uid = request.get_json().get('uid')
        user = User.query.filter_by(id=uid).first()
        if user.confirm(token):
            story = request.get_json().get('story')
            user.userwords += len(story)
            keyword1 = request.get_json().get('keyword')
            c = '&'
            keyword = ''
            for key in keyword1:
                a = keyword1[key] 
                keyword += (a + c)
            likenum = 0
            user.usb += 1
            user.usa += 1
            story1 = Story(story = story,
                            user_id = uid,
                            likenum = likenum,
                            keywords = keyword)
            db.session.add(story1,user)
            db.session.commit()
            return jsonify({
                "storyid":story1.id    
            }),200
Esempio n. 9
0
def new_story():
    if(session and session['logged_in']):
        if request.method == 'POST':

            story = Story(genre_id = request.form.get('genre_id'),
                        country_id = request.form.get('country_id'),
                        storytype_id = request.form.get('storytype_id'),
                        media_topic = request.form.get('media_topic'),
                        media_text = request.form.get('media_text'),
                        media_desc = request.form.get('media_desc'),
                        hidden = request.form.get('hidden') != None,
                        owner = session['username'],
                        create_time = utils.get_now(),
                        lang_id = 2)

            db.session.add(story)
            db.session.commit()
            flash("New story created")
            return redirect(url_for("home"))
        else:
            my_uploads = db.session.query(Uploads).filter(Uploads.user_id==session['user_id']).order_by(Uploads.create_time.desc())
            blobs = []
            for blob in my_uploads:
                blobs.append(blob)
            return render_template("user/new_story.html", blobs=blobs)
    else:
        flash("Please login first")
        return redirect(url_for("home"))
Esempio n. 10
0
    def add_stories(self):
        """
        Adds stories to the database
        :return:
        """
        authors = open("app/utils/authors.json", "r")
        stories = open("app/utils/stories.json", "r")

        with stories as story_data:
            loaded_stories = json.load(story_data)

        with authors as author_data:
            loaded_authors = json.load(author_data)

        author_story = list(zip(loaded_authors, loaded_stories))

        for au_st in author_story:
            author = AuthorAccount(first_name=au_st[0]["first_name"],
                                   last_name=au_st[0]["last_name"],
                                   email=au_st[0]["email"],
                                   username=au_st[0]["username"],
                                   password=au_st[0]["password"],
                                   registered_on=datetime.now())

            story = Story(title=au_st[1]["title"],
                          tagline=au_st[1]["tagline"],
                          category=au_st[1]["category"],
                          content=au_st[1]["content"],
                          author_id=author.id)
            db.session.add(author)
            db.session.add(story)
        db.session.commit()
Esempio n. 11
0
def write():
    if request.method == 'POST':
        token = request.headers['token']
        uid = request.get_json().get('uid')
        user = User.query.filter_by(id=uid).first()
        if user.confirm(token):
            user.usb = int(user.usb) + 1
            title = request.get_json().get('title')
            storyckeyword = request.get_json().get('storyckeyword')
            storyc = request.get_json().get('storyc')
            storykeyword = storyckeyword
            story = Story(title = title, 
                          likenum = 0,
                          keywords = storykeyword, 
                          user_id = uid)
            db.session.add(story)
            db.session.commit()
            storyc = Storyc(storyc = storyc,
                        likenum = 0,
                        storyckeyword = storyckeyword,
                        story_id = story.id,
                        user_id = uid)
            db.session.add(storyc)
            db.session.commit()
            return jsonify({
                "storyid":story.id    
            }),200
        else:
            return jsonify({}),403
Esempio n. 12
0
def write():
    if request.method == 'POST':
        token = request.headers['token']
        uid = request.get_json().get('uid')
        user = User.query.filter_by(id=uid).first()
        if user.confirm(token):
            user.usb = int(user.usb) + 1
            title = request.get_json().get('title')
            storyckeyword = request.get_json().get('storyckeyword')
            storyc = request.get_json().get('storyc')
            storykeyword = storyckeyword
            localtime = time.strftime('%Y-%m-%d %a %H:%M:%S',
                                      time.localtime(time.time()))
            story = Story(title=title,
                          likenum=0,
                          floors=1,
                          time=localtime,
                          keywords=storykeyword,
                          user_id=uid)
            db.session.add(story)
            db.session.commit()
            storyc = Storyc(storyc=storyc,
                            likenum=0,
                            storyckeyword=storyckeyword,
                            time=localtime,
                            story_id=story.id,
                            user_id=uid)
            db.session.add(storyc)
            db.session.commit()
            return jsonify({"storyid": story.id, "time": localtime}), 200
        else:
            return jsonify({}), 403
Esempio n. 13
0
def seite_sprint_post(sprint_id):
    db.session.autoflush = False
    sprint = Sprint.query.get_or_404(sprint_id)

    sprint.start = request.form.get("start")
    sprint.ende = request.form.get("ende")
    sprint.ziel = request.form.get("ziel")

    for story_data in json.loads(request.form.get("data")):
        story = Story.query.get(story_data.get("id"))
        if story_data.get("to_delete"):
            if story:
                db.session.delete(story)
            continue

        if not story:
            story = Story(sprint=sprint)
            db.session.add(story)

        story.titel = story_data.get("titel")
        story.beschreibung = story_data.get("beschreibung")

        for task_data in story_data.get("tasks", []):
            task = Task.query.get(task_data.get("id"))
            if task and task_data.get("delete", False):
                db.session.delete(task)
                continue

            if not task:
                task = Task()

            task.story = story
            task.name = task_data.get("name")
            task.user = User.query.get(task_data.get("user_id"))

            neuer_status = task_data.get("status")
            if task.status != neuer_status and neuer_status == 2:
                task._fertig_datum = datetime.now()
            task.status = neuer_status

            story.tasks.append(task)
            db.session.add(task)

    db.session.commit()

    return redirect(f"/sprints/{sprint_id}")
Esempio n. 14
0
def seed_stories():

    demo = Story(title='Title Demo',
                 body='This is a Body Demo',
                 author_id=User.query.filter_by(username='******').first().id)
    demo2 = Story(title="This is Bob's story",
                  body="This story is awesome",
                  author_id=User.query.filter_by(username='******').first().id)
    demo3 = Story(title='Who wrote this one?',
                  body='This story is written by no one',
                  author_id=User.query.filter_by(username='******').first().id)

    db.session.add(demo)
    db.session.add(demo2)
    db.session.add(demo3)

    db.session.commit()
Esempio n. 15
0
 def test_punctuation(self):
   p = create_project()
   story = Story.create(text="As a User, I want to add a user story, so that I document a requirement and sell the system. This is extra info", project_id=p.id)
   p.analyze()
   defect = story.defects.filter(Defect.subkind=='punctuation')[0]
   assert defect.kind == 'minimal'
   assert defect.subkind == 'punctuation'
   assert defect.severity == 'high'
Esempio n. 16
0
def index():
    form = OrderForm()
    print(form)
    if request.method == 'POST':
        buyer = Buyer(
            first_name=form.first_name.data,
            last_name=form.last_name.data,
            email=form.email.data,
            address_1=form.address_1.data,
            address_2=form.address_2.data,
            city=form.city.data,
            country=form.country.data,
            postal_code=form.postal_code.data,
            state=form.state.data,
        )
        db.session.add(buyer)
        db.session.commit()
        story = Story(
            nickname=form.nickname.data,
            nickname_gender=form.nickname_gender.data,
            location=form.location.data,
            dog=form.dog.data,
            friend=form.friend.data,
            friend_gender=form.friend_gender.data,
            cake=form.cake.data,
            cake_gender=form.cake_gender.data,
            body=form.body.data,
            author=Buyer.query.filter_by(email=form.email.data).first_or_404())
        story.link_album()
        db.session.add(story)
        db.session.commit()
        db_to_sheet(
            "buyer",
            'sqlite:///app.db',  #current_app.config["SQLALCHEMY_DATABASE_URI"],
            SHEET_REFERENCE,
            BUYER_TAB_NAME,
        )
        db_to_sheet(
            "story",
            'sqlite:///app.db',  #current_app.config["SQLALCHEMY_DATABASE_URI"],
            SHEET_REFERENCE,
            STORY_TAB_NAME,
        )
        flash(_('Votre commande a bien été enregistrée'))
        return redirect(url_for('main.index'))
    return render_template('index.html', form=form)
Esempio n. 17
0
 def test_brackets(self):
   p = create_project()
   story = Story.create(text="As a User, I want to add a user story, so that I document a requirement and sell the system (for money)", project_id=p.id)
   p.analyze()
   defect = story.defects.filter(Defect.subkind=='brackets')[0]
   assert defect.kind == 'minimal'
   assert defect.subkind == 'brackets'
   assert defect.severity == 'medium'
Esempio n. 18
0
 def test_not_atomic(self):
   p = create_project()
   story = Story.create(text="As a User, I want to add a user story, so that I document a requirement and sell the system", project_id=p.id)
   p.analyze()
   defect = story.defects.filter(Defect.subkind=='conjunctions')[0]
   assert defect.kind == 'atomic'
   assert defect.subkind == 'conjunctions'
   assert defect.severity == 'high'
Esempio n. 19
0
 def test_no_role(self):
   p = create_project()
   story = Story.create(text="User wants to add a user story, so that I document a requirement", project_id=p.id)
   p.analyze()
   defect = story.defects.filter(Defect.subkind=='no_role')[0]
   assert defect.kind == 'well_formed'
   assert defect.subkind == 'no_role'
   assert defect.severity == 'high'
   assert defect.highlight == "Add a role"
Esempio n. 20
0
 def generate(self):
     """Creates story by adding scenes to pages until the end is reached.
     Story added to MongoDB instance and the UUID of the story is returned to the caller"""
     pages = []
     self.characters[1] = self.locations[1].character  # load next non-user character
     pages.append(Pages(page=self.story_index, sentences=[self.realise(self.aggregation(['opening', 'intro'])),
                                                          self.realise(self.phrase('quest'))]))
     self.story_index += 1
     while not self.end:
         pages.append(Pages(page=self.story_index, sentences=self.scene()))
         self.add_location()
         self.story_index += 1
     pages.append(Pages(page=self.story_index,
                        sentences=[self.realise(self.phrase("end")), "And they all lived happily ever after.",
                                   "The end."]))
     story = Story(title=self.title, author=self.author, pages=pages)
     story.save()
     return story.id
Esempio n. 21
0
 def test_no_comma(self):
   p = create_project()
   story = Story.create(text="As a User I want to add a user story so that I document a requirement", project_id=p.id)
   p.analyze()
   defect = story.defects.all()[0]
   assert defect.kind == 'well_formed'
   assert defect.subkind == 'no_comma'
   assert defect.severity == 'medium'
   assert defect.highlight == "As a User<span class='highlight-text'>,</span> I want to add a user story"
Esempio n. 22
0
def postStory(request, format=None):
    storyJ = json.loads(json.dumps(request.data))
    print(storyJ)
    with transaction.atomic():
        story = Story(title=storyJ["title"], creator=request.user)
        story.save()
        for p in storyJ["pieces"]:
            if p == None:
                continue

            pType = p["type"]
            del p["type"]
            p["story"] = story.pk
            if pType == 0:
                piece = Piece()
                seriaP = PieceSerializer(piece, data=p)
                seriaP.is_valid(raise_exception=True)
                seriaP.save()
            elif pType == 1:
                piece = DecisionPiece()
                choices = p["choices"]
                del p["choices"]
                print(p)
                seriaD = DecisionSerializer(piece, data=p)
                seriaD.is_valid(raise_exception=True)
                seriaD.save()
                for c in choices:
                    print(c)
                    choice = ChoicePiece(story=story, decision=piece)
                    seriaC = ChoiceSerializer(choice, data=c)
                    seriaC.is_valid(raise_exception=True)
                    seriaC.save()
            elif pType == 2:
                piece = LosePiece()
                seriaP = LoseSerializer(piece, data=p)
                seriaP.is_valid(raise_exception=True)
                seriaP.save()
            elif pType == 3:
                piece = WinPiece()
                seriaP = WinSerializer(piece, data=p)
                seriaP.is_valid(raise_exception=True)
                seriaP.save()

    return HttpResponse(status=201)
Esempio n. 23
0
def newstory(request):
    if request.user.is_authenticated():
        elem = {
            'title': 'Ny Story',
        }
        if request.method == 'POST':
            story_form = StoryForm(request.POST)
            elem.update({
                'story_form': story_form,
            })

            if story_form.is_valid():
                print story_form.cleaned_data
                title = request.POST['title']
                length = request.POST['length']
                if request.POST.get('availability'):
                    availability = request.POST['availability']
                else:
                    availability = "Public"
                language = request.POST['language']
                category = request.POST['category']

                newstory = Story(created=datetime.datetime.now(),
                                 creator=request.user,
                                 title=title,
                                 length=length,
                                 availability=availability,
                                 language=language,
                                 category=category)
                newstory.save()
                return HttpResponseRedirect('/home')
            else:
                print "invalid story_form"
        else:
            story_form = StoryForm()
            elem.update({
                'story_form': story_form,
            })
        return render_to_response("newstory.html",
                                  elem,
                                  context_instance=RequestContext(request))
    else:
        return HttpResponseRedirect("/")
Esempio n. 24
0
def story():
    story1 = Story(title='Elephone1',
                   imgurl='elephone1.jpg',
                   location='AAA',
                   description='daassdfsdfkjfksljfklsjfljsdlfjsd',
                   author='Tim',
                   hitnumber=0,
                   available=True)
    story2 = Story(title='Montain1',
                   imgurl='images_11.jpg',
                   location='BBB',
                   description='dsfdfdaaskjfksljfklsjfljsdlfjsd',
                   author='Grace',
                   hitnumber=0,
                   available=True)
    story3 = Story(title='Sea1',
                   imgurl='images1.jpg',
                   location='CCC',
                   description='13232daaskjfksljfklsjfljsdlfjsd',
                   author='Tony',
                   hitnumber=3,
                   available=True)
    story4 = Story(title='Sea2',
                   imgurl='images2.jpg',
                   location='CCC',
                   description='13232daaskjfksljfklsjfljsdlfjsd',
                   author='Tony',
                   hitnumber=2,
                   available=True)
    story5 = Story(title='Sea3',
                   imgurl='images3.jpg',
                   location='CCC',
                   description='13232daaskjfksljfklsjfljsdlfjsd',
                   author='Tony',
                   hitnumber=1,
                   available=True)
    db.session.add(story1)
    db.session.add(story2)
    db.session.add(story3)
    db.session.add(story4)
    db.session.add(story5)
    db.session.commit()
Esempio n. 25
0
    def delete(self, story_uid):
        """Delete a slide from a user's story"""
        story = Story.get_active(uid=story_uid)
        if story is None:
            raise ResourceNotFound('Story not found')

        if story.user != get_current_user():
            raise UnauthorizedError()

        story.delete()

        return api_deleted_response()
Esempio n. 26
0
def add_story():
    title = request.json['title']
    body = request.json['body']
    author_id = User.query.filter_by(
        username=request.json['author']).first().id

    new_story = Story(title, body, author_id)

    db.session.add(new_story)
    db.session.commit()

    return {"id": new_story.id}
Esempio n. 27
0
    def create_authors():
        """
        creates dummy users and stories for this model test cases
        :return: new 
        """
        author1 = AuthorAccount(first_name="test11",
                                last_name="hadithi11",
                                username="******",
                                email="*****@*****.**",
                                password="******",
                                registered_on=datetime.now())

        author2 = AuthorAccount(first_name="test22",
                                last_name="hadithi22",
                                username="******",
                                email="*****@*****.**",
                                password="******",
                                registered_on=datetime.now())

        db.session.add(author1)
        db.session.add(author2)
        db.session.commit()

        story1 = Story(title="Some random story",
                       tagline="Dark city catches fire",
                       category="Fiction",
                       content="",
                       author_id=author1.id)

        story2 = Story(title="Anther Random story",
                       tagline="Dark city catches fire",
                       category="Fiction",
                       content="",
                       author_id=author2.id)

        db.session.add(story1)
        db.session.add(story2)
        db.session.commit()

        return author1, author2
Esempio n. 28
0
 def add_story(self):
     author = self.create_author_account()
     story = Story.query.filter_by(author_id=author.id).first()
     if story is None:
         try:
             story = Story(title="Gotham in flames",
                           tagline="Dark city catches fire",
                           content="",
                           author_id=author.id)
             db.session.add(story)
         except IntegrityError as e:
             print(e)
             db.session.rollback()
     return story
Esempio n. 29
0
def create_story():
    data = request.json
    story = Story(title=data["newStoryTitle"],
                  tier=data["tier"],
                  author_id=data["author_id"],
                  created_at=datetime.now())
    db.session.add(story)
    db.session.commit()
    db.session.flush()
    micro_story = Micro_Story(title=data["microStoryTitle"],
                              part=1,
                              content=data["content"],
                              story_id=story.id,
                              format_id=1)
    db.session.add(micro_story)
    db.session.commit()
    return {'Message': 'Success!', "storyId": story.id}
Esempio n. 30
0
 def add_story(self):
     """
     Adds a dummy story to the database
     :return:
     """
     author1, author2, author3, author4 = self.create_author_accounts()
     story = Story.query.filter_by(author_id=author1.id).first()
     if story is None:
         try:
             story = Story(title="Gotham in flames",
                           tagline="Dark city catches fire",
                           category="Fiction",
                           content="",
                           author_id=author1.id)
             db.session.add(story)
         except IntegrityError as e:
             print(e)
             db.session.rollback()
     return story
Esempio n. 31
0
def write_story(username):
    """
    Allows Author to write a new story
    :return new story template
    """
    story_form = StoryForm(request.form)
    user = current_user
    if request.method == "POST":
        if story_form.validate_on_submit():
            story = Story(title=story_form.story_title.data,
                          tagline=story_form.tagline.data,
                          category=story_form.category.data,
                          content=story_form.content.data,
                          author_id=user.id)
            db.session.add(story)
            db.session.commit()
            return redirect(
                url_for('dashboard.user_dashboard', username=user.full_name))
    return render_template("dashboard.new_story.html",
                           user=user,
                           story_form=story_form)
Esempio n. 32
0
def addStory(updateDat):
    assert 'story' in updateDat
    story = updateDat['story']

    assert 'name' in story
    assert 'auth' in story
    assert 'fname' in story
    assert 'file' in story
    assert 'desc' in story
    assert 'tags' in story

    data = DataURI(story['file'])

    dathash = getHash(data.data).lower()
    have = Story.query.filter(Story.hash == dathash).scalar()

    if have:
        # print("Have file already!")
        return getResponse(
            "A file with that MD5 hash already exists! Are you accidentally adding a duplicate?",
            True)

    have = Story.query.filter(Story.title == story['name']).scalar()
    if have:
        orig_name = story['name']
        loop = 2
        while have:
            print("Have story with that name ('%s')!" % story['name'])
            story['name'] = orig_name + " (%s)" % loop
            have = Story.query.filter(Story.title == story['name']).scalar()
            loop += 1
        print("Story added with number in name: '%s'" % story['name'])

    if len(story['name']) > 80:
        return getResponse("Maximum story title length is 80 characters!",
                           True)
    if len(story['name']) < 3:
        return getResponse("Minimum story title length is 3 characters!", True)
    if len(story['auth']) < 5:
        return getResponse("Minimum story author name length is 5 characters!",
                           True)
    if len(story['auth']) > 60:
        return getResponse(
            "Maximum story author name length is 60 characters!", True)
    if len(story['desc']) < 30:
        return getResponse(
            "Minimum story description length is 30 characters!", True)
    if len(story['desc']) > 500:
        return getResponse(
            "Maximum story description length is 500 characters!", True)

    fspath = saveFile(data.data, story['fname'])

    stags = ["-".join(itm_tags.split(" ")) for itm_tags in story['tags']]
    stags = [bleach.clean(tag, tags=[], strip=True) for tag in stags]

    # print("Author: ", story['auth'])
    # print("stags: ", story['tags'])
    # print("stags: ", stags)

    post_date = datetime.datetime.now()
    if 'ul_date' in story and isinstance(story['ul_date'], datetime.datetime):
        post_date = story['ul_date']

    new = Story(
        title=bleach.clean(story['name'], tags=[], strip=True),
        srcfname=story['fname'],
        description=markdown.markdown(bleach.clean(story['desc'], strip=True)),
        fspath=fspath,
        hash=dathash,
        # author      = [story['auth']],
        # tags        = stags,
        pub_date=post_date)

    [new.tags.append(Tags(tag=tag)) for tag in stags]
    new.author.append(
        Author(name=bleach.clean(story['auth'], tags=[], strip=True)))

    db.session.add(new)
    db.session.commit()

    flash('Your story has been added! Thanks for posting your content!')
    return getResponse("Story added", error=False)
Esempio n. 33
0
def create_story(project_id):
  s = Story.create(text="As a User, I want to add a user story, so that I document a requirement", project_id=project_id)
  return s
Esempio n. 34
0
 def test_role_means_ends_chunks(self):
   p = create_project()
   s = Story.create(text="As a User, I want to add a user story, so that I document a requirement", project_id=p.id)
   assert s.role == "As a User,"
   assert s.means == "I want to add a user story,"
   assert s.ends == "so that I document a requirement"
Esempio n. 35
0
 def test_well_formed(self):
   p = create_project()
   s = Story.create(text="As a User, I'm able to add a user story, so that I document a requirement", project_id=p.id)
   s.analyze()
   assert len(s.defects.all()) == 0