def create(self, request, **kwargs):
     serializer = BranchSerializer(data=request.data)
     if serializer.is_valid():
         user = save_user(request.data, UserPermissions.IS_BRANCH)
         company = Company(**request.data["company"])
         city = City(**request.data["city"])
         branch = Branch(
             nickName=request.data["nickName"],
             type=UserType.BRANCH,
             address=request.data["address"],
             phone=request.data["phone"],
             company=company,
             city=city,
             user=user,
         )
         branch.save()
         return Response(
             {
                 "status": "SUCCESS",
                 "msg_status": "Sucursal creada satisfactoriamente. Puede ingresar con su nueva contrasena.",
             }
         )
     else:
         messages = []
         make_error(serializer.errors.values(), messages)
         return Response({"status": "FAILURE", "msg_status": messages})

class BranchTestCase(unittest.TestCase):
    
    def setUp(self):
                
        #the memcache will contain values that will break the tests
        #dont run this on production!
        memcache.flush_all()
        
        # First, create an instance of the Testbed class.
        self.testbed = testbed.Testbed()
        # Then activate the testbed, which prepares the service stubs for use.
        self.testbed.activate()
        # Create a consistency policy that will simulate the High Replication consistency model.
        self.policy = datastore_stub_util.PseudoRandomHRConsistencyPolicy(probability=0)
        # Initialize the datastore stub with this policy.
        self.testbed.init_datastore_v3_stub(consistency_policy=self.policy)
        
        
        millis = int(round(time.time() * 1000))
        
        tree_name = 'test_tree' + str(millis)
        
        username = 'test_user' + str(millis)
        
        self.parent_branch = Branch(id=tree_name)
        
        self.parent_branch.author_name = username
        self.parent_branch.link = ''
        self.parent_branch.content = ''
        self.parent_branch.put()
        
        self.child_branchs = []
        
    def tearDown(self):
        for branch in self.child_branchs:
            branch.key.delete()
        
        self.parent_branch.key.delete()
        
        self.testbed.deactivate()
        
    def testUpdateNoDuplicate(self):
        
        
        branch = Branch()
        branch.link = 'testIdenticalLink.some_link'
        branch.content = 'some_content'
        
        branch.revision = 0
        branch.parent_branch = self.parent_branch.key
        branch.parent_branch_authorname = self.parent_branch.authorname
        branch.put()
        
        self.parent_branch.append_child(branch)
        
        self.assertTrue(len(self.parent_branch.children()) == 1)
        
        self.child_branchs.append(branch)

    def __init__(self):
        # FIXME: This function is massive. Break it up
        self._test_map = {}
        platform_id_map = {}
        branch_id_map = {}
        for test in Test.all():
            if test.hidden:
                continue

            branch_ids = [Branch.get(branch_key).id for branch_key in test.branches]
            platform_ids = [Platform.get(platform_key).id for platform_key in test.platforms]
            self._test_map[test.id] = {
                'name': test.name,
                'branchIds': branch_ids,
                'platformIds': platform_ids,
            }

            for platform_id in platform_ids:
                platform_id_map.setdefault(platform_id, {'tests': [], 'branches': []})
                platform_id_map[platform_id]['tests'].append(test.id)
                platform_id_map[platform_id]['branches'] += branch_ids

            for branch_id in branch_ids:
                branch_id_map.setdefault(branch_id, {'tests': [], 'platforms': []})
                branch_id_map[branch_id]['tests'].append(test.id)
                branch_id_map[branch_id]['platforms'] += platform_ids

        self._platform_map = {}
        for platform in Platform.all():
            if platform.id not in platform_id_map:
                continue

            if platform.hidden:
                for test_id in platform_id_map[platform.id]['tests']:
                    self._test_map[test_id]['platformIds'].remove(platform.id)
                for branch_id in platform_id_map[platform.id]['branches']:
                    branch_id_map[branch_id]['platforms'].remove(platform.id)
                continue

            self._platform_map[platform.id] = {
                'name': platform.name,
                'testIds': list(set(platform_id_map[platform.id]['tests'])),
                'branchIds': list(set(platform_id_map[platform.id]['branches'])),
            }

        self._branch_map = {}
        for branch in Branch.all():
            if branch.id not in branch_id_map:
                continue
            self._branch_map[branch.id] = {
                'name': branch.name,
                'testIds': list(set(branch_id_map[branch.id]['tests'])),
                'platformIds': list(set(branch_id_map[branch.id]['platforms'])),
            }

 def setUp(self):
             
     #the memcache will contain values that will break the tests
     #dont run this on production!
     memcache.flush_all()
     
     # First, create an instance of the Testbed class.
     self.testbed = testbed.Testbed()
     # Then activate the testbed, which prepares the service stubs for use.
     self.testbed.activate()
     # Create a consistency policy that will simulate the High Replication consistency model.
     self.policy = datastore_stub_util.PseudoRandomHRConsistencyPolicy(probability=0)
     # Initialize the datastore stub with this policy.
     self.testbed.init_datastore_v3_stub(consistency_policy=self.policy)
     
     
     millis = int(round(time.time() * 1000))
     
     tree_name = 'test_tree' + str(millis)
     
     username = 'test_user' + str(millis)
     
     self.parent_branch = Branch(id=tree_name)
     
     self.parent_branch.author_name = username
     self.parent_branch.link = ''
     self.parent_branch.content = ''
     self.parent_branch.put()
     
     self.child_branchs = []

    def get(self):
        self.response.headers['Content-Type'] = 'application/json; charset=utf-8';
        cache = memcache.get('dashboard')
        if cache:
            self.response.out.write(cache)
            return

        webkit_trunk = Branch.get_by_key_name('webkit-trunk')

        # FIXME: Determine popular branches, platforms, and tests
        dashboard = {
            'defaultBranch': 'WebKit trunk',
            'branchToId': {webkit_trunk.name: webkit_trunk.id},
            'platformToId': {},
            'testToId': {},
        }

        for platform in Platform.all():
            dashboard['platformToId'][platform.name] = platform.id

        for test in Test.all():
            dashboard['testToId'][test.name] = test.id

        result = json.dumps(dashboard)
        self.response.out.write(result)
        memcache.add('dashboard', result)

def update_create(request, id=0):
    if request.method not in ['GET', 'POST']:
        return HttpResponseNotAllowed(permitted_methods=['GET', 'POST'])
    instance = None
    if id:
        instance = get_object_or_404(Lab, pk=id)
    if request.method == 'GET':
        form = MedicalLabForm(instance)
    elif request.method == 'POST':
        form = MedicalLabForm(request.POST, instance=instance)
        if form.is_valid():
            with transaction.commit_on_success():
                lab = form.save()
                # Only add lab, main branch in new lab creation
                if not instance:
                    request.user.lab = lab
                    request.user.save()
                    Branch.create_main_branch(lab)
    return render(request, 'add_update.html', {'form':form})

 def testValidator(self):
 
     test_link_text = "a"*24
     test_content_text = "b"*24
     
     branch = Branch()
     branch.link = test_link_text
     branch.content = test_content_text
     branch.put()
     
     self.assertEqual(branch.link, test_link_text)
     self.assertEqual(branch.content, test_content_text)
     
     branch = Branch()
     branch.link = "<a>"+test_link_text+"</a>"
     branch.content = "<a>"+test_content_text+"</a>"
     branch.put()
     
     self.assertEqual(branch.link, test_link_text)
     self.assertEqual(branch.content, test_content_text)

 def get(self):
     
     trees = Tree.main_trees()
     branchdatas = Branch.get_first_branchs(trees)
     template_values = {
         'trees': trees,
         'branchdatas': branchdatas,
         'username': self.username()
     }
     
     self.render('main.html', template_values)

 def testUpdateNoDuplicate(self):
     
     
     branch = Branch()
     branch.link = 'testIdenticalLink.some_link'
     branch.content = 'some_content'
     
     branch.revision = 0
     branch.parent_branch = self.parent_branch.key
     branch.parent_branch_authorname = self.parent_branch.authorname
     branch.put()
     
     self.parent_branch.append_child(branch)
     
     self.assertTrue(len(self.parent_branch.children()) == 1)
     
     self.child_branchs.append(branch)